use super::path_vocab::{
block_label, canonical_segment, fold_canonical_segments, path_within, resolve_self_super,
strip_block_segments,
};
use super::token_tree::{AngleSlot, Delimiter, Kind, Node, TokenTree};
const ITEM_QUALIFIERS: [&str; 7] = [
"unsafe", "safe", "async", "const", "extern", "default", "auto",
];
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) enum Visibility {
Private,
Public,
Super,
In(String),
}
impl Visibility {
pub(super) fn visible_from(&self, owner: &str, from: &str) -> bool {
match self {
Visibility::Public => true,
Visibility::Private => path_within(from, owner),
Visibility::Super => path_within(
from,
strip_block_segments(
owner
.rsplit_once("::")
.map_or("crate", |(parent, _)| parent),
),
),
Visibility::In(written) => {
let parts: Vec<&str> = written.split("::").map(str::trim).collect();
match resolve_self_super(owner, &parts).or_else(|| fold_canonical_segments(&parts))
{
Some(region) => path_within(from, ®ion),
None => true,
}
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum ItemKeyword {
Mod,
Struct,
Enum,
Union,
Trait,
Type,
Fn,
Const,
Static,
Impl,
Use,
ExternCrate,
ExternBlock,
MacroRules,
}
#[derive(Clone, Debug)]
pub(super) struct ItemHead {
pub start: usize,
pub keyword: ItemKeyword,
pub keyword_at: usize,
pub name: Option<usize>,
pub visibility: Visibility,
pub body: Option<usize>,
pub value_struct: bool,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) enum GroupKind {
ModuleBody(String),
Block,
MemberBody,
ExternBlock,
CfgIf,
CfgArm,
UseGroup,
MacroBody,
Other,
}
pub(super) fn is_outer_attribute(node: Node) -> bool {
matches!(node, Node::Attribute { hash, open, .. } if open == hash + 1)
}
pub(super) fn attribute_path<'t>(
tree: &'t TokenTree<'_>,
start: usize,
end: usize,
) -> (Option<&'t str>, usize) {
let mut k = start;
let mut segments = Vec::new();
while k < end && (tree.is_word(k) || tree.kind(k) == Kind::Keyword || tree.is(k, "::")) {
if !tree.is(k, "::") {
segments.push(tree.text(k));
}
k += 1;
}
let single = (segments.len() == 1 && !tree.is(start, "::")).then(|| segments[0]);
(single, k)
}
pub(super) fn cfg_written_before(tree: &TokenTree, start: usize) -> bool {
let mut metas = Vec::new();
let mut k = start;
while let Some(node @ Node::Attribute { open, close, .. }) = tree.node_before(k) {
if !is_outer_attribute(node) {
break;
}
metas.push((open + 1, close));
k = node.first();
}
while let Some((start, end)) = metas.pop() {
match attribute_path(tree, start, end) {
(Some("cfg"), _) => return true,
(Some("cfg_attr"), after) if tree.kind(after) == Kind::Open(Delimiter::Parenthesis) => {
metas.extend(cfg_attr_metas(tree, after));
}
_ => {}
}
}
false
}
pub(super) fn may_be_cfg_gated(tree: &TokenTree, start: usize) -> bool {
cfg_written_before(tree, start)
|| tree.enclosing(start).is_some_and(|open| {
tree.kind(open) == Kind::Open(Delimiter::Brace)
&& tree
.enclosing(open)
.is_some_and(|outer| macro_group_kind(tree, outer) == Some(GroupKind::CfgIf))
&& (matches!(tree.node_before(open), Some(Node::Attribute { .. }))
|| open.checked_sub(1).is_some_and(|e| tree.is(e, "else")))
})
}
pub(super) fn cfg_attr_metas(tree: &TokenTree, open: usize) -> Vec<(usize, usize)> {
let close = tree.partner(open);
let mut metas = Vec::new();
let mut k = open + 1;
let mut meta = k;
let mut past_predicate = false;
while k <= close {
if k == close || tree.is(k, ",") {
if past_predicate && meta < k {
metas.push((meta, k));
}
past_predicate = true;
meta = k + 1;
k += 1;
continue;
}
k = tree.node_at(k).last() + 1;
}
metas
}
fn macro_name_of(tree: &TokenTree, open: usize) -> Option<usize> {
if let Some(name) = open
.checked_sub(2)
.filter(|&n| tree.is(n + 1, "!") && tree.is_word(n))
{
return Some(name);
}
let m = open.checked_sub(3)?;
tree.opens_a_macro_rules(m).then_some(m)
}
pub(super) fn macro_group_kind(tree: &TokenTree, open: usize) -> Option<GroupKind> {
macro_name_of(tree, open).map(|name| {
if tree.text(name) == "cfg_if" {
GroupKind::CfgIf
} else {
GroupKind::MacroBody
}
})
}
fn opens_an_opaque_macro_body(tree: &TokenTree, open: usize) -> bool {
macro_group_kind(tree, open) == Some(GroupKind::MacroBody)
}
pub(super) fn in_macro_body(tree: &TokenTree, i: usize) -> bool {
let mut at = tree.enclosing(i);
while let Some(open) = at {
if opens_an_opaque_macro_body(tree, open) {
return true;
}
at = tree.enclosing(open);
}
false
}
pub(super) fn in_attribute(tree: &TokenTree, i: usize) -> bool {
let mut at = tree.enclosing(i);
while let Some(open) = at {
if tree.kind(open) == Kind::Open(Delimiter::Bracket)
&& open.checked_sub(1).is_some_and(|before| {
tree.is(before, "#")
|| (tree.is(before, "!")
&& before.checked_sub(1).is_some_and(|hash| tree.is(hash, "#")))
})
{
return true;
}
at = tree.enclosing(open);
}
false
}
pub(super) struct BlockModule {
pub head: ItemHead,
pub name_at: usize,
pub owner: Option<usize>,
pub label: String,
}
pub(super) fn block_modules(tree: &TokenTree) -> Vec<BlockModule> {
let mut counts: std::collections::BTreeMap<(Option<usize>, String), usize> = Default::default();
let mut found = Vec::new();
for i in 0..tree.len() {
if tree.kind(i) != Kind::Keyword || tree.text(i) != "mod" || in_macro_body(tree, i) {
continue;
}
let mut in_block = false;
let mut owner = None;
let mut at = tree.enclosing(i);
while let Some(open) = at {
match classify_group(tree, open, None) {
GroupKind::ModuleBody(_) => {
owner = Some(open);
break;
}
GroupKind::CfgIf | GroupKind::CfgArm => {}
_ => in_block = true,
}
at = tree.enclosing(open);
}
if !in_block {
continue;
}
let Some((head, name_at)) =
item_at_keyword(tree, i).and_then(|head| head.name.map(|name| (head, name)))
else {
continue;
};
let count = counts
.entry((owner, canonical_segment(tree.text(name_at)).to_string()))
.or_default();
*count += 1;
found.push(BlockModule {
head,
name_at,
owner,
label: block_label(*count),
});
}
found
}
pub(super) fn is_cfg_if_arm(tree: &TokenTree, open: usize) -> bool {
tree.kind(open) == Kind::Open(Delimiter::Brace)
&& macro_group_kind(tree, open).is_none()
&& tree
.enclosing(open)
.is_some_and(|outer| macro_group_kind(tree, outer) == Some(GroupKind::CfgIf))
&& (matches!(tree.node_before(open), Some(Node::Attribute { .. }))
|| open.checked_sub(1).is_some_and(|e| tree.is(e, "else")))
}
pub(super) fn classify_group(
tree: &TokenTree,
open: usize,
parent: Option<&GroupKind>,
) -> GroupKind {
if let Some(kind) = macro_group_kind(tree, open) {
return kind;
}
if tree.kind(open) != Kind::Open(Delimiter::Brace) {
return GroupKind::Other;
}
if is_cfg_if_arm(tree, open) {
return GroupKind::CfgArm;
}
if parent == Some(&GroupKind::UseGroup) {
return GroupKind::UseGroup;
}
match item_owning(tree, open) {
Some(head) => match head.keyword {
ItemKeyword::Mod => match head.name {
Some(name) => GroupKind::ModuleBody(tree.text(name).to_string()),
None => GroupKind::Block,
},
ItemKeyword::Struct
| ItemKeyword::Enum
| ItemKeyword::Union
| ItemKeyword::Trait
| ItemKeyword::Impl => GroupKind::MemberBody,
ItemKeyword::ExternBlock => GroupKind::ExternBlock,
ItemKeyword::Use => GroupKind::UseGroup,
_ => GroupKind::Block,
},
None => GroupKind::Block,
}
}
fn item_owning(tree: &TokenTree, open: usize) -> Option<ItemHead> {
let head = item_from(tree, start_after_boundary(tree, open, |_| false))?;
(head.keyword == ItemKeyword::Use || head.body == Some(open)).then_some(head)
}
pub(super) fn owner_start(tree: &TokenTree, open: usize) -> usize {
match item_owning(tree, open) {
Some(head) => head.start,
None => start_after_boundary(
tree,
open,
|node| matches!(node, Node::Token(t) if tree.is(t, ",")),
),
}
}
fn start_after_boundary(tree: &TokenTree, open: usize, also_ends: impl Fn(Node) -> bool) -> usize {
let mut start = open;
while let Some(node) = tree.node_before(start) {
if (is_boundary_node(tree, node) && !inside_an_angle_group(tree, node)) || also_ends(node) {
break;
}
start = node.first();
}
start
}
fn inside_an_angle_group(tree: &TokenTree, node: Node) -> bool {
let Node::Group { open, .. } = node else {
return false;
};
let before = open.wrapping_sub(1);
(tree.is(before, "<") || tree.is(before, "<<") || tree.is(before, ",") || tree.is(before, "="))
&& angles(tree)[open].enclosed
}
fn is_boundary_node(tree: &TokenTree, node: Node) -> bool {
match node {
Node::Token(t) => tree.is(t, ";"),
Node::Group { open, .. } => tree.kind(open) == Kind::Open(Delimiter::Brace),
Node::Macro { name, open, .. } => {
tree.kind(open) == Kind::Open(Delimiter::Brace) && macro_stands_as_an_item(tree, name)
}
Node::Attribute { .. } => true,
}
}
pub(super) fn heads_a_path(tree: &TokenTree, i: usize) -> bool {
i < tree.len()
&& match tree.kind(i) {
Kind::Ident | Kind::RawIdent => true,
Kind::Keyword => matches!(tree.text(i), "self" | "Self" | "super" | "crate"),
_ => false,
}
}
pub(super) fn macro_stands_as_an_item(tree: &TokenTree, name: usize) -> bool {
let mut start = name;
while start >= 2 && tree.is(start - 1, "::") && heads_a_path(tree, start - 2) {
start -= 2;
}
if start >= 1 && tree.is(start - 1, "::") {
start -= 1;
}
if !in_an_item_list(tree, start) {
return false;
}
let Some(before) = start.checked_sub(1) else {
return true;
};
match tree.kind(before) {
Kind::Open(Delimiter::Brace) | Kind::Close(Delimiter::Brace) => true,
Kind::Close(Delimiter::Bracket) => {
matches!(tree.node_before(start), Some(Node::Attribute { .. }))
}
_ => tree.is(before, ";"),
}
}
fn in_an_item_list(tree: &TokenTree, i: usize) -> bool {
tree.enclosing(i)
.is_none_or(|open| tree.kind(open) == Kind::Open(Delimiter::Brace))
}
fn is_item_start(tree: &TokenTree, i: usize) -> bool {
in_an_item_list(tree, i)
&& tree
.node_before(i)
.is_none_or(|node| is_boundary_node(tree, node))
}
fn item_keyword(tree: &TokenTree, j: usize) -> Option<ItemKeyword> {
if j >= tree.len() {
return None;
}
let keyword = match (tree.kind(j), tree.text(j)) {
(Kind::Keyword, "mod") => ItemKeyword::Mod,
(Kind::Keyword, "struct") => ItemKeyword::Struct,
(Kind::Keyword, "enum") => ItemKeyword::Enum,
(Kind::Keyword, "trait") => ItemKeyword::Trait,
(Kind::Keyword, "type") => ItemKeyword::Type,
(Kind::Keyword, "fn") => ItemKeyword::Fn,
(Kind::Keyword, "const")
if (tree.is_word(j + 1) || tree.is(j + 1, "_")) && tree.is(j + 2, ":") =>
{
ItemKeyword::Const
}
(Kind::Keyword, "static") => ItemKeyword::Static,
(Kind::Keyword, "impl") => ItemKeyword::Impl,
(Kind::Keyword, "use") => ItemKeyword::Use,
(Kind::Keyword, "extern") if tree.is(j + 1, "crate") => ItemKeyword::ExternCrate,
(Kind::Keyword, "extern") => {
let after = if tree.kind(j + 1) == Kind::Literal {
j + 2
} else {
j + 1
};
(tree.kind(after) == Kind::Open(Delimiter::Brace))
.then_some(ItemKeyword::ExternBlock)?
}
(Kind::Ident, "union") if tree.is_word(j + 1) => ItemKeyword::Union,
(Kind::Ident, "macro_rules") if tree.is(j + 1, "!") => ItemKeyword::MacroRules,
_ => return None,
};
Some(keyword)
}
fn visibility_at(tree: &TokenTree, pub_at: usize) -> (Visibility, usize) {
let open = pub_at + 1;
if tree.kind(open) != Kind::Open(Delimiter::Parenthesis) {
return (Visibility::Public, pub_at + 1);
}
let close = tree.partner(open);
let words: Vec<&str> = (open + 1..close).map(|k| tree.text(k)).collect();
let visibility = match words.as_slice() {
["crate"] => Visibility::Public,
["self"] => Visibility::Private,
["super"] => Visibility::Super,
["in", rest @ ..] => Visibility::In(rest.concat()),
_ => Visibility::Public,
};
(visibility, close + 1)
}
fn item_from(tree: &TokenTree, start: usize) -> Option<ItemHead> {
if start >= tree.len() || !is_item_start(tree, start) {
return None;
}
let mut j = start;
let mut visibility = Visibility::Private;
loop {
if tree.is(j, "pub") {
let (v, next) = visibility_at(tree, j);
visibility = v;
j = next;
continue;
}
if item_keyword(tree, j).is_some() {
break;
}
if j < tree.len()
&& ITEM_QUALIFIERS.contains(&tree.text(j))
&& matches!(tree.kind(j), Kind::Keyword | Kind::Ident)
{
j += 1;
if tree.is(j - 1, "extern") && tree.kind(j) == Kind::Literal {
j += 1;
}
continue;
}
return None;
}
let keyword = item_keyword(tree, j)?;
let keyword_at = j;
let name = match keyword {
ItemKeyword::Impl | ItemKeyword::Use | ItemKeyword::ExternBlock => None,
ItemKeyword::MacroRules => Some(j + 2).filter(|&n| tree.is_word(n)),
ItemKeyword::ExternCrate => Some(j + 2).filter(|&n| tree.is_word(n) || tree.is(n, "self")),
ItemKeyword::Static if tree.is(j + 1, "mut") => Some(j + 2).filter(|&n| tree.is_word(n)),
_ => Some(j + 1).filter(|&n| tree.is_word(n)),
};
let (body, value_struct) = match keyword {
ItemKeyword::Mod
| ItemKeyword::Struct
| ItemKeyword::Enum
| ItemKeyword::Union
| ItemKeyword::Trait
| ItemKeyword::Impl
| ItemKeyword::Fn
| ItemKeyword::ExternBlock => item_body(tree, name.map_or(j + 1, |n| n + 1), keyword),
_ => (None, false),
};
Some(ItemHead {
start,
keyword,
keyword_at,
name,
visibility,
body,
value_struct,
})
}
pub(super) fn item_at_keyword(tree: &TokenTree, keyword_at: usize) -> Option<ItemHead> {
item_keyword(tree, keyword_at)?;
let mut start = keyword_at;
while let Some(node) = tree.node_before(start) {
let first = node.first();
let qualifies = match node {
Node::Token(t) => {
(matches!(tree.kind(t), Kind::Keyword | Kind::Ident)
&& (ITEM_QUALIFIERS.contains(&tree.text(t)) || tree.is(t, "pub")))
|| (tree.kind(t) == Kind::Literal
&& t.checked_sub(1).is_some_and(|e| tree.is(e, "extern")))
}
Node::Group { open, .. } => {
tree.kind(open) == Kind::Open(Delimiter::Parenthesis)
&& open.checked_sub(1).is_some_and(|p| tree.is(p, "pub"))
}
_ => false,
};
if !qualifies {
break;
}
start = first;
}
item_from(tree, start).filter(|head| head.keyword_at == keyword_at)
}
pub(super) fn visibility_before(tree: &TokenTree, keyword_at: usize) -> Visibility {
item_at_keyword(tree, keyword_at).map_or(Visibility::Private, |head| head.visibility)
}
fn item_body(tree: &TokenTree, from: usize, keyword: ItemKeyword) -> (Option<usize>, bool) {
let mut k = from;
let mut after_where = false;
while k < tree.len() {
if let Node::Macro { close, .. } = tree.node_at(k) {
k = close + 1;
continue;
}
match tree.kind(k) {
Kind::Open(Delimiter::Brace) => return (Some(k), false),
Kind::Open(Delimiter::Parenthesis)
if keyword == ItemKeyword::Struct && !after_where =>
{
return (None, true);
}
Kind::Open(_) => {
k = tree.partner(k) + 1;
continue;
}
Kind::Close(_) => return (None, false),
_ if tree.is(k, ";") => return (None, keyword == ItemKeyword::Struct),
_ if opens_an_angle_group(tree, k) => {
k = angle_group_end(tree, k).map_or(k + 1, |close| close + 1);
continue;
}
_ if tree.is(k, "where") => after_where = true,
_ => {}
}
k += 1;
}
(None, false)
}
pub(super) struct AngleGroup {
pub close: usize,
pub inner_close: Option<usize>,
}
pub(super) fn angle_group(tree: &TokenTree, open: usize) -> Option<AngleGroup> {
let slot = angles(tree).get(open)?;
slot.close.map(|close| AngleGroup {
close,
inner_close: slot.inner_close,
})
}
fn angles<'t>(tree: &'t TokenTree<'_>) -> &'t [AngleSlot] {
tree.angle_slots(|| {
let mut slots = vec![AngleSlot::default(); tree.len()];
let level = |k: usize| tree.enclosing(k).map_or(0, |open| open + 1);
let mut open: Vec<Vec<(usize, isize, bool)>> = vec![Vec::new(); tree.len() + 1];
let mut depth = vec![0isize; tree.len() + 1];
for k in 0..tree.len() {
match tree.kind(k) {
Kind::Open(_) => continue,
Kind::Close(_) => {
open[tree.partner(k) + 1].clear();
continue;
}
_ => {}
}
let at = level(k);
if tree.is(k, ";") {
open[at].clear();
continue;
}
let delta = match tree.text(k) {
"<" | "<-" => 1,
"<<" => 2,
">" | ">=" => -1,
">>" | ">>=" => -2,
_ => 0,
};
let before = depth[at];
depth[at] += delta;
while let Some(&(opener, waits_for, inner)) = open[at].last() {
if depth[at] > waits_for {
break;
}
open[at].pop();
if inner {
slots[opener].inner_close = Some(k);
} else {
slots[opener].close = Some(k);
}
}
if opens_an_angle_group(tree, k) {
open[at].push((k, before, false));
if tree.is(k, "<<") {
open[at].push((k, before + 1, true));
}
}
}
let mut reach = vec![0usize; tree.len() + 1];
for (k, slot) in slots.iter_mut().enumerate() {
let at = level(k);
if matches!(tree.kind(k), Kind::Open(_)) {
slot.enclosed = reach[at] > k;
} else if let Some(close) = slot.close {
reach[at] = reach[at].max(close);
}
}
slots
})
}
pub(super) fn opens_an_angle_group(tree: &TokenTree, k: usize) -> bool {
tree.is(k, "<") || tree.is(k, "<<") || tree.is(k, "<-")
}
pub(super) fn angle_group_end(tree: &TokenTree, open: usize) -> Option<usize> {
angle_group(tree, open).map(|group| group.close)
}
const OPERAND_KEYWORDS: [&str; 7] = ["self", "Self", "super", "crate", "true", "false", "await"];
fn ends_an_operand(tree: &TokenTree, i: usize) -> bool {
let Some(prev) = i.checked_sub(1) else {
return false;
};
match tree.kind(prev) {
Kind::Ident | Kind::RawIdent | Kind::Literal | Kind::Close(_) => true,
Kind::Keyword => OPERAND_KEYWORDS.contains(&tree.text(prev)),
Kind::Punct => tree.text(prev) == "?",
Kind::Lifetime | Kind::Open(_) | Kind::End => false,
}
}
fn opens_a_generic_list(tree: &TokenTree, i: usize) -> bool {
let Some(prev) = i.checked_sub(1) else {
return false;
};
tree.kind(prev) == Kind::Keyword
&& match tree.text(prev) {
"impl" => true,
"for" => tree.kind(i + 1) == Kind::Lifetime,
_ => false,
}
}
pub(super) fn opens_a_qualified_path(tree: &TokenTree, i: usize) -> Option<usize> {
if ends_an_operand(tree, i) || opens_a_generic_list(tree, i) {
return None;
}
let close = angle_group_end(tree, i)?;
tree.is(close + 1, "::").then_some(close + 1)
}
pub(super) fn variant_positions(tree: &TokenTree) -> std::collections::BTreeSet<usize> {
let mut names = std::collections::BTreeSet::new();
for open in 0..tree.len() {
if tree.kind(open) != Kind::Open(Delimiter::Brace)
|| !item_owning(tree, open).is_some_and(|head| head.keyword == ItemKeyword::Enum)
{
continue;
}
let close = tree.partner(open);
let mut k = open + 1;
let mut expect_name = true;
while k < close {
let node = tree.node_at(k);
if let Node::Attribute { close, .. } = node {
k = close + 1;
continue;
}
let turbofish = opens_an_angle_group(tree, k)
&& k.checked_sub(1).is_some_and(|before| tree.is(before, "::"));
let close = if turbofish {
angle_group_end(tree, k)
} else {
opens_a_qualified_path(tree, k).map(|tail| tail - 1)
};
if let Some(close) = close {
expect_name = false;
k = close + 1;
continue;
}
if expect_name && tree.is_word(k) {
names.insert(k);
}
expect_name = tree.is(k, ",");
k = node.last() + 1;
}
}
names
}
#[cfg(test)]
mod tests {
use super::super::token_tree::Edition;
use super::*;
#[test]
fn a_discriminants_turbofish_separates_no_variants() {
let source = "pub enum E { A = f::<u8, m::K>(), B = 1 << 3, C = 64 >> 1, D = 1 + <u8 as Tr<u8, m::K>>::X, F }";
let tree = TokenTree::lex(source, Edition::Rust2018);
let names: Vec<&str> = variant_positions(&tree)
.into_iter()
.map(|k| tree.text(k))
.collect();
assert_eq!(names, ["A", "B", "C", "D", "F"]);
}
fn kind_of(source: &str, brace: usize) -> GroupKind {
let tree = TokenTree::lex(source, Edition::Rust2018);
let opens: Vec<usize> = (0..tree.len())
.filter(|&i| tree.kind(i) == Kind::Open(Delimiter::Brace))
.collect();
classify_group(&tree, opens[brace], None)
}
#[test]
fn a_group_is_classified_by_the_header_before_it() {
assert_eq!(
kind_of("pub(crate) mod inner { }", 0),
GroupKind::ModuleBody("inner".into())
);
assert_eq!(
kind_of("#[cfg(x)] mod r#type { }", 0),
GroupKind::ModuleBody("type".into())
);
assert_eq!(kind_of("pub fn f() -> Vec<u8> { }", 0), GroupKind::Block);
assert_eq!(
kind_of("impl<T> Tr for X<T> where T: Fn() -> u8 { }", 0),
GroupKind::MemberBody
);
assert_eq!(kind_of("enum E { A }", 0), GroupKind::MemberBody);
assert_eq!(
kind_of("unsafe extern \"C\" { }", 0),
GroupKind::ExternBlock
);
assert_eq!(kind_of("fn g() { unsafe { } }", 1), GroupKind::Block);
assert_eq!(
kind_of("thread_local! { } mod m { }", 1),
GroupKind::ModuleBody("m".into())
);
assert_eq!(kind_of("fn g() -> impl Tr { }", 0), GroupKind::Block);
}
#[test]
fn an_item_starts_only_after_a_boundary() {
let tree = TokenTree::lex(
"fn f(x: impl Tr) -> fn() { } pub(super) unsafe fn g() {}",
Edition::Rust2018,
);
let impl_at = (0..tree.len()).find(|&i| tree.is(i, "impl")).unwrap();
assert!(item_at_keyword(&tree, impl_at).is_none());
let fns: Vec<usize> = (0..tree.len()).filter(|&i| tree.is(i, "fn")).collect();
assert!(item_at_keyword(&tree, fns[0]).is_some());
assert!(
item_at_keyword(&tree, fns[1]).is_none(),
"a fn pointer type is no item"
);
let g = item_at_keyword(&tree, fns[2]).unwrap();
assert_eq!(g.visibility, Visibility::Super);
assert_eq!(tree.text(g.name.unwrap()), "g");
}
#[test]
fn a_const_fn_declares_no_const() {
let tree = TokenTree::lex(
"const fn f() {} const _: u8 = 0; const { }",
Edition::Rust2018,
);
let consts: Vec<usize> = (0..tree.len()).filter(|&i| tree.is(i, "const")).collect();
assert!(item_at_keyword(&tree, consts[0]).is_none());
assert!(item_at_keyword(&tree, consts[1]).is_some_and(|h| h.name.is_none()));
assert!(item_at_keyword(&tree, consts[2]).is_none());
}
#[test]
fn a_tuple_or_unit_struct_declares_a_value() {
for (source, value) in [
("struct P(u8);", true),
("struct U;", true),
("struct S { a: u8 }", false),
("struct S<F> where F: Fn() { f: F }", false),
("struct P<const N: usize = { 3 }>(u8);", true),
] {
let tree = TokenTree::lex(source, Edition::Rust2018);
let head = item_at_keyword(&tree, 0).unwrap();
assert_eq!(head.value_struct, value, "{source}");
}
}
#[test]
fn an_angle_group_closes_as_rustc_splits_it() {
let tree = TokenTree::lex("< Vec < fn ( ) -> u8 >> ; x", Edition::Rust2018);
assert_eq!(angle_group_end(&tree, 0), Some(8));
let tree = TokenTree::lex("< a ; >", Edition::Rust2018);
assert_eq!(angle_group_end(&tree, 0), None);
let tree = TokenTree::lex("< T : Into < u8 >>= Y", Edition::Rust2018);
assert_eq!(angle_group_end(&tree, 0), Some(6));
let tree = TokenTree::lex("< T >= Y", Edition::Rust2018);
assert_eq!(angle_group_end(&tree, 0), Some(2));
}
#[test]
fn a_shift_opening_two_groups_closes_the_inner_one_first() {
for (source, inner, close) in [
("<< u8 as T > :: x >", 4, 7),
("<< A < B >> :: x >", 4, 7),
("<< u8 >>", 2, 2),
] {
let tree = TokenTree::lex(source, Edition::Rust2018);
let group = angle_group(&tree, 0).unwrap();
assert_eq!(
(group.inner_close, group.close),
(Some(inner), close),
"{source}"
);
}
let tree = TokenTree::lex("< u8 >", Edition::Rust2018);
assert_eq!(angle_group(&tree, 0).unwrap().inner_close, None);
}
}