hir_def/nameres/
attr_resolution.rs

1//! Post-nameres attribute resolution.
2
3use base_db::Crate;
4use hir_expand::{
5    MacroCallId, MacroCallKind, MacroDefId,
6    attrs::{Attr, AttrId, AttrInput},
7    inert_attr_macro::find_builtin_attr_idx,
8    mod_path::{ModPath, PathKind},
9};
10use span::SyntaxContext;
11use syntax::ast;
12use triomphe::Arc;
13
14use crate::{
15    AstIdWithPath, LocalModuleId, MacroId, UnresolvedMacro,
16    db::DefDatabase,
17    item_scope::BuiltinShadowMode,
18    nameres::{LocalDefMap, path_resolution::ResolveMode},
19};
20
21use super::{DefMap, MacroSubNs};
22
23pub enum ResolvedAttr {
24    /// Attribute resolved to an attribute macro.
25    Macro(MacroCallId),
26    /// Attribute resolved to something else that does not require expansion.
27    Other,
28}
29
30impl DefMap {
31    pub(crate) fn resolve_attr_macro(
32        &self,
33        local_def_map: &LocalDefMap,
34        db: &dyn DefDatabase,
35        original_module: LocalModuleId,
36        ast_id: AstIdWithPath<ast::Item>,
37        attr: &Attr,
38    ) -> Result<ResolvedAttr, UnresolvedMacro> {
39        // NB: does not currently work for derive helpers as they aren't recorded in the `DefMap`
40
41        if self.is_builtin_or_registered_attr(&ast_id.path) {
42            return Ok(ResolvedAttr::Other);
43        }
44
45        let resolved_res = self.resolve_path_fp_with_macro(
46            local_def_map,
47            db,
48            ResolveMode::Other,
49            original_module,
50            &ast_id.path,
51            BuiltinShadowMode::Module,
52            Some(MacroSubNs::Attr),
53        );
54        let def = match resolved_res.resolved_def.take_macros() {
55            Some(def) => {
56                // `MacroSubNs` is just a hint, so the path may still resolve to a custom derive
57                // macro, or even function-like macro when the path is qualified.
58                if def.is_attribute(db) {
59                    def
60                } else {
61                    return Ok(ResolvedAttr::Other);
62                }
63            }
64            None => return Err(UnresolvedMacro { path: ast_id.path.as_ref().clone() }),
65        };
66
67        Ok(ResolvedAttr::Macro(attr_macro_as_call_id(
68            db,
69            &ast_id,
70            attr,
71            self.krate,
72            db.macro_def(def),
73        )))
74    }
75
76    pub(crate) fn is_builtin_or_registered_attr(&self, path: &ModPath) -> bool {
77        if path.kind != PathKind::Plain {
78            return false;
79        }
80
81        let segments = path.segments();
82
83        if let Some(name) = segments.first() {
84            let name = name.symbol();
85            let pred = |n: &_| *n == *name;
86
87            let is_tool = self.data.registered_tools.iter().any(pred);
88            // FIXME: tool modules can be shadowed by actual modules
89            if is_tool {
90                return true;
91            }
92
93            if segments.len() == 1 && find_builtin_attr_idx(name).is_some() {
94                return true;
95            }
96        }
97        false
98    }
99}
100
101pub(super) fn attr_macro_as_call_id(
102    db: &dyn DefDatabase,
103    item_attr: &AstIdWithPath<ast::Item>,
104    macro_attr: &Attr,
105    krate: Crate,
106    def: MacroDefId,
107) -> MacroCallId {
108    let arg = match macro_attr.input.as_deref() {
109        Some(AttrInput::TokenTree(tt)) => {
110            let mut tt = tt.clone();
111            tt.top_subtree_delimiter_mut().kind = tt::DelimiterKind::Invisible;
112            Some(tt)
113        }
114
115        _ => None,
116    };
117
118    def.make_call(
119        db,
120        krate,
121        MacroCallKind::Attr {
122            ast_id: item_attr.ast_id,
123            attr_args: arg.map(Arc::new),
124            invoc_attr_index: macro_attr.id,
125        },
126        macro_attr.ctxt,
127    )
128}
129
130pub(super) fn derive_macro_as_call_id(
131    db: &dyn DefDatabase,
132    item_attr: &AstIdWithPath<ast::Adt>,
133    derive_attr_index: AttrId,
134    derive_pos: u32,
135    call_site: SyntaxContext,
136    krate: Crate,
137    resolver: impl Fn(&ModPath) -> Option<(MacroId, MacroDefId)>,
138    derive_macro_id: MacroCallId,
139) -> Result<(MacroId, MacroDefId, MacroCallId), UnresolvedMacro> {
140    let (macro_id, def_id) = resolver(&item_attr.path)
141        .filter(|(_, def_id)| def_id.is_derive())
142        .ok_or_else(|| UnresolvedMacro { path: item_attr.path.as_ref().clone() })?;
143    let call_id = def_id.make_call(
144        db,
145        krate,
146        MacroCallKind::Derive {
147            ast_id: item_attr.ast_id,
148            derive_index: derive_pos,
149            derive_attr_index,
150            derive_macro_id,
151        },
152        call_site,
153    );
154    Ok((macro_id, def_id, call_id))
155}
hir_def/nameres/attr_resolution.rs

hir_def/nameres/
attr_resolution.rs
