use proc_macro2::TokenStream;
use syn::parse::{ParseStream, Parser as _};
use syn::{
Attribute, ForeignItemFn, ForeignItemType, MacroDelimiter, Meta, Token, UseTree, Visibility,
braced, token,
};
pub(crate) enum Verbatim {
UseGroup(UseGroup),
Bodiless(Bodiless),
}
pub(crate) struct UseGroup {
pub(crate) attrs: Vec<Attribute>,
pub(crate) vis: Visibility,
pub(crate) members: Vec<UseMember>,
}
pub(crate) struct UseMember {
pub(crate) leading_colon: bool,
pub(crate) tree: UseTree,
}
pub(crate) enum Bodiless {
Fn(Box<ForeignItemFn>),
Type(Box<ForeignItemType>),
}
pub(crate) fn item(tokens: &TokenStream) -> Option<Verbatim> {
match split_use_group.parse2(tokens.clone()) {
Ok(group) => Some(Verbatim::UseGroup(group)),
Err(_) => member(tokens).map(Verbatim::Bodiless),
}
}
pub fn visit_grouped_import(
tokens: &TokenStream,
mut visitor: impl FnMut(&[Attribute], bool, &UseTree),
) -> bool {
let Ok(group) = split_use_group.parse2(tokens.clone()) else {
return false;
};
for member in &group.members {
visitor(&group.attrs, member.leading_colon, &member.tree);
}
true
}
pub(crate) fn member(tokens: &TokenStream) -> Option<Bodiless> {
if let Ok(f) = syn::parse2::<ForeignItemFn>(tokens.clone()) {
return Some(Bodiless::Fn(Box::new(f)));
}
syn::parse2::<ForeignItemType>(tokens.clone())
.ok()
.map(|t| Bodiless::Type(Box::new(t)))
}
pub(crate) fn definitely_disabled(tokens: &TokenStream) -> bool {
let parse = |input: ParseStream<'_>| {
let attributes = input.call(Attribute::parse_outer)?;
let _: TokenStream = input.parse()?;
Ok(attributes.iter().any(|attribute| {
matches!(
&attribute.meta,
Meta::List(cfg) if cfg.path.is_ident("cfg")
&& matches!(cfg.delimiter, MacroDelimiter::Paren(_))
) && matches!(
attribute.parse_args::<Meta>(),
Ok(Meta::List(any)) if any.path.is_ident("any")
&& matches!(any.delimiter, MacroDelimiter::Paren(_))
&& any.tokens.is_empty()
)
}))
};
parse.parse2(tokens.clone()).unwrap_or(false)
}
fn split_use_group(input: ParseStream<'_>) -> syn::Result<UseGroup> {
let attrs = input.call(Attribute::parse_outer)?;
let vis: Visibility = input.parse()?;
input.parse::<Token![use]>()?;
let content;
braced!(content in input);
input.parse::<Token![;]>()?;
let mut members = Vec::new();
split_members(&content, &mut members)?;
Ok(UseGroup {
attrs,
vis,
members,
})
}
fn split_members(content: ParseStream<'_>, members: &mut Vec<UseMember>) -> syn::Result<()> {
while !content.is_empty() {
if content.peek(token::Brace) {
let inner;
braced!(inner in content);
split_members(&inner, members)?;
} else {
let leading_colon = content.parse::<Option<Token![::]>>()?.is_some();
let tree: UseTree = content.parse()?;
members.push(UseMember {
leading_colon,
tree,
});
}
if content.is_empty() {
break;
}
content.parse::<Token![,]>()?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::{Bodiless, Verbatim, item, member};
fn tokens(text: &str) -> proc_macro2::TokenStream {
text.parse().expect("tokens")
}
#[test]
fn a_use_group_splits_into_one_use_per_member() {
let Some(Verbatim::UseGroup(group)) = item(&tokens(
"#[cfg(x)] pub use { ::std::fmt::Debug as D, crate::a::{f, g}, };",
)) else {
panic!("not a use group");
};
assert_eq!(group.members.len(), 2);
assert!(group.members[0].leading_colon);
assert!(!group.members[1].leading_colon);
assert_eq!(group.attrs.len(), 1);
assert!(matches!(group.vis, syn::Visibility::Public(_)));
}
#[test]
fn a_bare_group_in_a_use_group_contributes_its_members() {
let Some(Verbatim::UseGroup(group)) =
item(&tokens("use { a::f, { ::b::c, { ::d::e } }, {} };"))
else {
panic!("not a use group");
};
let colons: Vec<bool> = group.members.iter().map(|m| m.leading_colon).collect();
assert_eq!(colons, [false, true, true]);
}
#[test]
fn a_use_group_is_not_read_in_an_impl_block() {
assert!(member(&tokens("use { ::a::b };")).is_none());
}
#[test]
fn bodiless_functions_and_types_are_read() {
assert!(matches!(
item(&tokens("#[m] pub(crate) const fn f(x: &str) -> &Self;")),
Some(Verbatim::Bodiless(Bodiless::Fn(_)))
));
assert!(matches!(
member(&tokens("#[ty(cast)] type bool;")),
Some(Bodiless::Type(_))
));
}
#[test]
fn other_shapes_are_not_read() {
for text in [
"trait Alias = Send;",
"use { a::{::b} };",
"use { ::a::b } extra;",
"use ::{ ::a::b };",
"const X: u8;",
"type T: Bound;",
"impl Tr for T;",
] {
assert!(item(&tokens(text)).is_none(), "{text}");
}
}
}