1use proc_macro2::TokenStream;
26use syn::parse::{ParseStream, Parser as _};
27use syn::{
28 Attribute, ForeignItemFn, ForeignItemType, MacroDelimiter, Meta, Token, UseTree, Visibility,
29 braced, token,
30};
31
32pub(crate) enum Verbatim {
34 UseGroup(UseGroup),
36 Bodiless(Bodiless),
38}
39
40pub(crate) struct UseGroup {
42 pub(crate) attrs: Vec<Attribute>,
44 pub(crate) vis: Visibility,
46 pub(crate) members: Vec<UseMember>,
48}
49
50pub(crate) struct UseMember {
52 pub(crate) leading_colon: bool,
54 pub(crate) tree: UseTree,
56}
57
58pub(crate) enum Bodiless {
60 Fn(Box<ForeignItemFn>),
62 Type(Box<ForeignItemType>),
64}
65
66pub(crate) fn item(tokens: &TokenStream) -> Option<Verbatim> {
69 match split_use_group.parse2(tokens.clone()) {
70 Ok(group) => Some(Verbatim::UseGroup(group)),
71 Err(_) => member(tokens).map(Verbatim::Bodiless),
72 }
73}
74
75pub fn visit_grouped_import(
79 tokens: &TokenStream,
80 mut visitor: impl FnMut(&[Attribute], bool, &UseTree),
81) -> bool {
82 let Ok(group) = split_use_group.parse2(tokens.clone()) else {
83 return false;
84 };
85 for member in &group.members {
86 visitor(&group.attrs, member.leading_colon, &member.tree);
87 }
88 true
89}
90
91pub(crate) fn member(tokens: &TokenStream) -> Option<Bodiless> {
94 if let Ok(f) = syn::parse2::<ForeignItemFn>(tokens.clone()) {
95 return Some(Bodiless::Fn(Box::new(f)));
96 }
97 syn::parse2::<ForeignItemType>(tokens.clone())
98 .ok()
99 .map(|t| Bodiless::Type(Box::new(t)))
100}
101
102pub(crate) fn definitely_disabled(tokens: &TokenStream) -> bool {
104 let parse = |input: ParseStream<'_>| {
105 let attributes = input.call(Attribute::parse_outer)?;
106 let _: TokenStream = input.parse()?;
107 Ok(attributes.iter().any(|attribute| {
108 matches!(
109 &attribute.meta,
110 Meta::List(cfg) if cfg.path.is_ident("cfg")
111 && matches!(cfg.delimiter, MacroDelimiter::Paren(_))
112 ) && matches!(
113 attribute.parse_args::<Meta>(),
114 Ok(Meta::List(any)) if any.path.is_ident("any")
115 && matches!(any.delimiter, MacroDelimiter::Paren(_))
116 && any.tokens.is_empty()
117 )
118 }))
119 };
120 parse.parse2(tokens.clone()).unwrap_or(false)
121}
122
123fn split_use_group(input: ParseStream<'_>) -> syn::Result<UseGroup> {
128 let attrs = input.call(Attribute::parse_outer)?;
129 let vis: Visibility = input.parse()?;
130 input.parse::<Token![use]>()?;
131 let content;
132 braced!(content in input);
133 input.parse::<Token![;]>()?;
134 let mut members = Vec::new();
135 split_members(&content, &mut members)?;
136 Ok(UseGroup {
137 attrs,
138 vis,
139 members,
140 })
141}
142
143fn split_members(content: ParseStream<'_>, members: &mut Vec<UseMember>) -> syn::Result<()> {
147 while !content.is_empty() {
148 if content.peek(token::Brace) {
149 let inner;
150 braced!(inner in content);
151 split_members(&inner, members)?;
152 } else {
153 let leading_colon = content.parse::<Option<Token![::]>>()?.is_some();
154 let tree: UseTree = content.parse()?;
155 members.push(UseMember {
156 leading_colon,
157 tree,
158 });
159 }
160 if content.is_empty() {
161 break;
162 }
163 content.parse::<Token![,]>()?;
164 }
165 Ok(())
166}
167
168#[cfg(test)]
169mod tests {
170 use super::{Bodiless, Verbatim, item, member};
171
172 fn tokens(text: &str) -> proc_macro2::TokenStream {
173 text.parse().expect("tokens")
174 }
175
176 #[test]
177 fn a_use_group_splits_into_one_use_per_member() {
178 let Some(Verbatim::UseGroup(group)) = item(&tokens(
179 "#[cfg(x)] pub use { ::std::fmt::Debug as D, crate::a::{f, g}, };",
180 )) else {
181 panic!("not a use group");
182 };
183 assert_eq!(group.members.len(), 2);
184 assert!(group.members[0].leading_colon);
185 assert!(!group.members[1].leading_colon);
186 assert_eq!(group.attrs.len(), 1);
187 assert!(matches!(group.vis, syn::Visibility::Public(_)));
188 }
189
190 #[test]
191 fn a_bare_group_in_a_use_group_contributes_its_members() {
192 let Some(Verbatim::UseGroup(group)) =
193 item(&tokens("use { a::f, { ::b::c, { ::d::e } }, {} };"))
194 else {
195 panic!("not a use group");
196 };
197 let colons: Vec<bool> = group.members.iter().map(|m| m.leading_colon).collect();
198 assert_eq!(colons, [false, true, true]);
199 }
200
201 #[test]
202 fn a_use_group_is_not_read_in_an_impl_block() {
203 assert!(member(&tokens("use { ::a::b };")).is_none());
204 }
205
206 #[test]
207 fn bodiless_functions_and_types_are_read() {
208 assert!(matches!(
209 item(&tokens("#[m] pub(crate) const fn f(x: &str) -> &Self;")),
210 Some(Verbatim::Bodiless(Bodiless::Fn(_)))
211 ));
212 assert!(matches!(
213 member(&tokens("#[ty(cast)] type bool;")),
214 Some(Bodiless::Type(_))
215 ));
216 }
217
218 #[test]
219 fn other_shapes_are_not_read() {
220 for text in [
221 "trait Alias = Send;",
222 "use { a::{::b} };",
223 "use { ::a::b } extra;",
224 "use ::{ ::a::b };",
225 "const X: u8;",
226 "type T: Bound;",
227 "impl Tr for T;",
228 ] {
229 assert!(item(&tokens(text)).is_none(), "{text}");
230 }
231 }
232}