| //! Builtin attributes. |
| use span::{MacroCallId, Span}; |
| |
| use crate::{db::ExpandDatabase, name, tt, ExpandResult, MacroCallKind}; |
| |
| macro_rules! register_builtin { |
| ($expand_fn:ident: $(($name:ident, $variant:ident) => $expand:ident),* ) => { |
| #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
| pub enum BuiltinAttrExpander { |
| $($variant),* |
| } |
| |
| impl BuiltinAttrExpander { |
| pub fn $expand_fn( |
| &self, |
| db: &dyn ExpandDatabase, |
| id: MacroCallId, |
| tt: &tt::Subtree, |
| ) -> ExpandResult<tt::Subtree> { |
| let expander = match *self { |
| $( BuiltinAttrExpander::$variant => $expand, )* |
| }; |
| expander(db, id, tt) |
| } |
| |
| fn find_by_name(name: &name::Name) -> Option<Self> { |
| match name { |
| $( id if id == &name::name![$name] => Some(BuiltinAttrExpander::$variant), )* |
| _ => None, |
| } |
| } |
| } |
| |
| }; |
| } |
| |
| impl BuiltinAttrExpander { |
| pub fn is_derive(self) -> bool { |
| matches!(self, BuiltinAttrExpander::Derive | BuiltinAttrExpander::DeriveConst) |
| } |
| pub fn is_test(self) -> bool { |
| matches!(self, BuiltinAttrExpander::Test) |
| } |
| pub fn is_bench(self) -> bool { |
| matches!(self, BuiltinAttrExpander::Bench) |
| } |
| } |
| |
| register_builtin! { expand: |
| (bench, Bench) => dummy_attr_expand, |
| (cfg, Cfg) => dummy_attr_expand, |
| (cfg_attr, CfgAttr) => dummy_attr_expand, |
| (cfg_accessible, CfgAccessible) => dummy_attr_expand, |
| (cfg_eval, CfgEval) => dummy_attr_expand, |
| (derive, Derive) => derive_expand, |
| // derive const is equivalent to derive for our proposes. |
| (derive_const, DeriveConst) => derive_expand, |
| (global_allocator, GlobalAllocator) => dummy_attr_expand, |
| (test, Test) => dummy_attr_expand, |
| (test_case, TestCase) => dummy_attr_expand |
| } |
| |
| pub fn find_builtin_attr(ident: &name::Name) -> Option<BuiltinAttrExpander> { |
| BuiltinAttrExpander::find_by_name(ident) |
| } |
| |
| fn dummy_attr_expand( |
| _db: &dyn ExpandDatabase, |
| _id: MacroCallId, |
| tt: &tt::Subtree, |
| ) -> ExpandResult<tt::Subtree> { |
| ExpandResult::ok(tt.clone()) |
| } |
| |
| /// We generate a very specific expansion here, as we do not actually expand the `#[derive]` attribute |
| /// itself in name res, but we do want to expand it to something for the IDE layer, so that the input |
| /// derive attributes can be downmapped, and resolved as proper paths. |
| /// This is basically a hack, that simplifies the hacks we need in a lot of ide layer places to |
| /// somewhat inconsistently resolve derive attributes. |
| /// |
| /// As such, we expand `#[derive(Foo, bar::Bar)]` into |
| /// ``` |
| /// #![Foo] |
| /// #![bar::Bar] |
| /// ``` |
| /// which allows fallback path resolution in hir::Semantics to properly identify our derives. |
| /// Since we do not expand the attribute in nameres though, we keep the original item. |
| /// |
| /// The ideal expansion here would be for the `#[derive]` to re-emit the annotated item and somehow |
| /// use the input paths in its output as well. |
| /// But that would bring two problems with it, for one every derive would duplicate the item token tree |
| /// wasting a lot of memory, and it would also require some way to use a path in a way that makes it |
| /// always resolve as a derive without nameres recollecting them. |
| /// So this hacky approach is a lot more friendly for us, though it does require a bit of support in |
| /// [`hir::Semantics`] to make this work. |
| fn derive_expand( |
| db: &dyn ExpandDatabase, |
| id: MacroCallId, |
| tt: &tt::Subtree, |
| ) -> ExpandResult<tt::Subtree> { |
| let loc = db.lookup_intern_macro_call(id); |
| let derives = match &loc.kind { |
| MacroCallKind::Attr { attr_args: Some(attr_args), .. } if loc.def.is_attribute_derive() => { |
| attr_args |
| } |
| _ => { |
| return ExpandResult::ok(tt::Subtree::empty(tt::DelimSpan { |
| open: loc.call_site, |
| close: loc.call_site, |
| })) |
| } |
| }; |
| pseudo_derive_attr_expansion(tt, derives, loc.call_site) |
| } |
| |
| pub fn pseudo_derive_attr_expansion( |
| tt: &tt::Subtree, |
| args: &tt::Subtree, |
| call_site: Span, |
| ) -> ExpandResult<tt::Subtree> { |
| let mk_leaf = |char| { |
| tt::TokenTree::Leaf(tt::Leaf::Punct(tt::Punct { |
| char, |
| spacing: tt::Spacing::Alone, |
| span: call_site, |
| })) |
| }; |
| |
| let mut token_trees = Vec::new(); |
| for tt in args |
| .token_trees |
| .split(|tt| matches!(tt, tt::TokenTree::Leaf(tt::Leaf::Punct(tt::Punct { char: ',', .. })))) |
| { |
| token_trees.push(mk_leaf('#')); |
| token_trees.push(mk_leaf('!')); |
| token_trees.push(mk_leaf('[')); |
| token_trees.extend(tt.iter().cloned()); |
| token_trees.push(mk_leaf(']')); |
| } |
| ExpandResult::ok(tt::Subtree { delimiter: tt.delimiter, token_trees }) |
| } |