1 //! Defines database & queries for macro expansion.
5 use base_db::{salsa, SourceDatabase};
6 use itertools::Itertools;
8 use mbe::{ExpandError, ExpandResult};
9 use parser::{FragmentKind, T};
12 ast::{self, AttrsOwner, NameOwner},
13 AstNode, GreenNode, Parse, SyntaxNode, SyntaxToken, TextRange,
17 ast_id_map::AstIdMap, hygiene::HygieneFrame, BuiltinAttrExpander, BuiltinDeriveExpander,
18 BuiltinFnLikeExpander, HirFileId, HirFileIdRepr, MacroCallId, MacroCallKind, MacroCallLoc,
19 MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander,
22 /// Total limit on the number of tokens produced by any macro invocation.
24 /// If an invocation produces more tokens than this limit, it will not be stored in the database and
25 /// an error will be emitted.
27 /// Actual max for `analysis-stats .` at some point: 30672.
28 static TOKEN_LIMIT: Limit = Limit::new(524_288);
30 #[derive(Debug, Clone, Eq, PartialEq)]
31 pub enum TokenExpander {
32 /// Old-style `macro_rules`.
33 MacroRules { mac: mbe::MacroRules, def_site_token_map: mbe::TokenMap },
35 MacroDef { mac: mbe::MacroDef, def_site_token_map: mbe::TokenMap },
36 /// Stuff like `line!` and `file!`.
37 Builtin(BuiltinFnLikeExpander),
38 /// `global_allocator` and such.
39 BuiltinAttr(BuiltinAttrExpander),
40 /// `derive(Copy)` and such.
41 BuiltinDerive(BuiltinDeriveExpander),
42 /// The thing we love the most here in rust-analyzer -- procedural macros.
43 ProcMacro(ProcMacroExpander),
52 ) -> mbe::ExpandResult<tt::Subtree> {
54 TokenExpander::MacroRules { mac, .. } => mac.expand(tt),
55 TokenExpander::MacroDef { mac, .. } => mac.expand(tt),
56 TokenExpander::Builtin(it) => it.expand(db, id, tt),
57 TokenExpander::BuiltinAttr(it) => it.expand(db, id, tt),
58 TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt),
59 TokenExpander::ProcMacro(_) => {
60 // We store the result in salsa db to prevent non-deterministic behavior in
61 // some proc-macro implementation
62 // See #4315 for details
63 db.expand_proc_macro(id)
68 pub(crate) fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
70 TokenExpander::MacroRules { mac, .. } => mac.map_id_down(id),
71 TokenExpander::MacroDef { mac, .. } => mac.map_id_down(id),
72 TokenExpander::Builtin(..)
73 | TokenExpander::BuiltinAttr(..)
74 | TokenExpander::BuiltinDerive(..)
75 | TokenExpander::ProcMacro(..) => id,
79 pub(crate) fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, mbe::Origin) {
81 TokenExpander::MacroRules { mac, .. } => mac.map_id_up(id),
82 TokenExpander::MacroDef { mac, .. } => mac.map_id_up(id),
83 TokenExpander::Builtin(..)
84 | TokenExpander::BuiltinAttr(..)
85 | TokenExpander::BuiltinDerive(..)
86 | TokenExpander::ProcMacro(..) => (id, mbe::Origin::Call),
91 // FIXME: rename to ExpandDatabase
92 #[salsa::query_group(AstDatabaseStorage)]
93 pub trait AstDatabase: SourceDatabase {
94 fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
96 /// Main public API -- parses a hir file, not caring whether it's a real
97 /// file or a macro expansion.
99 fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
100 /// Implementation for the macro case.
101 fn parse_macro_expansion(
103 macro_file: MacroFile,
104 ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>>;
106 /// Macro ids. That's probably the tricksiest bit in rust-analyzer, and the
107 /// reason why we use salsa at all.
109 /// We encode macro definitions into ids of macro calls, this what allows us
110 /// to be incremental.
112 fn intern_macro(&self, macro_call: MacroCallLoc) -> MacroCallId;
114 /// Lowers syntactic macro call to a token tree representation.
115 #[salsa::transparent]
116 fn macro_arg(&self, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>>;
117 /// Extracts syntax node, corresponding to a macro call. That's a firewall
118 /// query, only typing in the macro call itself changes the returned
120 fn macro_arg_text(&self, id: MacroCallId) -> Option<GreenNode>;
121 /// Gets the expander for this macro. This compiles declarative macros, and
122 /// just fetches procedural ones.
123 fn macro_def(&self, id: MacroDefId) -> Option<Arc<TokenExpander>>;
125 /// Expand macro call to a token tree. This query is LRUed (we keep 128 or so results in memory)
126 fn macro_expand(&self, macro_call: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>>;
127 /// Special case of the previous query for procedural macros. We can't LRU
128 /// proc macros, since they are not deterministic in general, and
129 /// non-determinism breaks salsa in a very, very, very bad way. @edwin0cheng
130 /// heroically debugged this once!
131 fn expand_proc_macro(&self, call: MacroCallId) -> ExpandResult<tt::Subtree>;
132 /// Firewall query that returns the error from the `macro_expand` query.
133 fn macro_expand_error(&self, macro_call: MacroCallId) -> Option<ExpandError>;
135 fn hygiene_frame(&self, file_id: HirFileId) -> Arc<HygieneFrame>;
138 /// This expands the given macro call, but with different arguments. This is
139 /// used for completion, where we want to see what 'would happen' if we insert a
140 /// token. The `token_to_map` mapped down into the expansion, with the mapped
142 pub fn expand_speculative(
143 db: &dyn AstDatabase,
144 actual_macro_call: MacroCallId,
145 speculative_args: &ast::TokenTree,
146 token_to_map: SyntaxToken,
147 ) -> Option<(SyntaxNode, SyntaxToken)> {
148 let (tt, tmap_1) = mbe::syntax_node_to_token_tree(speculative_args.syntax());
150 token_to_map.text_range().checked_sub(speculative_args.syntax().text_range().start())?;
151 let token_id = tmap_1.token_by_range(range)?;
154 let loc: MacroCallLoc = db.lookup_intern_macro(actual_macro_call);
155 db.macro_def(loc.def)?
158 let speculative_expansion = macro_def.expand(db, actual_macro_call, &tt);
160 let fragment_kind = macro_fragment_kind(db, actual_macro_call);
163 mbe::token_tree_to_syntax_node(&speculative_expansion.value, fragment_kind).ok()?;
165 let token_id = macro_def.map_id_down(token_id);
166 let range = tmap_2.first_range_by_token(token_id, token_to_map.kind())?;
167 let token = node.syntax_node().covering_element(range).into_token()?;
168 Some((node.syntax_node(), token))
171 fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
172 let map = db.parse_or_expand(file_id).map(|it| AstIdMap::from_source(&it)).unwrap_or_default();
176 fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
178 HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
179 HirFileIdRepr::MacroFile(macro_file) => {
180 db.parse_macro_expansion(macro_file).value.map(|(it, _)| it.syntax_node())
185 fn parse_macro_expansion(
186 db: &dyn AstDatabase,
187 macro_file: MacroFile,
188 ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
189 let _p = profile::span("parse_macro_expansion");
190 let result = db.macro_expand(macro_file.macro_call_id);
192 if let Some(err) = &result.err {
194 // The final goal we would like to make all parse_macro success,
195 // such that the following log will not call anyway.
196 let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
197 let node = loc.kind.to_node(db);
199 // collect parent information for warning log
201 std::iter::successors(loc.kind.file_id().call_node(db), |it| it.file_id.call_node(db))
202 .map(|n| format!("{:#}", n.value))
207 "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
213 let tt = match result.value {
215 None => return ExpandResult { value: None, err: result.err },
218 let fragment_kind = macro_fragment_kind(db, macro_file.macro_call_id);
220 tracing::debug!("expanded = {}", tt.as_debug_string());
221 tracing::debug!("kind = {:?}", fragment_kind);
223 let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
227 "failed to parse expansion to {:?} = {}",
231 return ExpandResult::only_err(err);
237 // Safety check for recursive identity macro.
238 let node = parse.syntax_node();
239 let file: HirFileId = macro_file.into();
240 let call_node = match file.call_node(db) {
243 return ExpandResult::only_err(err);
246 if is_self_replicating(&node, &call_node.value) {
247 ExpandResult::only_err(err)
249 ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
253 tracing::debug!("parse = {:?}", parse.syntax_node().kind());
254 ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None }
259 fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
260 let arg = db.macro_arg_text(id)?;
261 let loc = db.lookup_intern_macro(id);
263 let node = SyntaxNode::new_root(arg);
264 let censor = match loc.kind {
265 MacroCallKind::FnLike { .. } => None,
266 MacroCallKind::Derive { derive_attr_index, .. } => match ast::Item::cast(node.clone()) {
269 .map(|attr| attr.syntax().text_range())
270 .take(derive_attr_index as usize + 1)
271 .fold1(TextRange::cover),
274 MacroCallKind::Attr { invoc_attr_index, .. } => match ast::Item::cast(node.clone()) {
276 item.attrs().nth(invoc_attr_index as usize).map(|attr| attr.syntax().text_range())
281 let (mut tt, tmap) = mbe::syntax_node_to_token_tree_censored(&node, censor);
283 if loc.def.is_proc_macro() {
284 // proc macros expect their inputs without parentheses, MBEs expect it with them included
288 Some(Arc::new((tt, tmap)))
291 fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
292 let loc = db.lookup_intern_macro(id);
293 let arg = loc.kind.arg(db)?;
294 if matches!(loc.kind, MacroCallKind::FnLike { .. }) {
295 let first = arg.first_child_or_token().map_or(T![.], |it| it.kind());
296 let last = arg.last_child_or_token().map_or(T![.], |it| it.kind());
298 matches!((first, last), (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']));
300 // Don't expand malformed (unbalanced) macro invocations. This is
301 // less than ideal, but trying to expand unbalanced macro calls
302 // sometimes produces pathological, deeply nested code which breaks
303 // all kinds of things.
305 // Some day, we'll have explicit recursion counters for all
306 // recursive things, at which point this code might be removed.
307 cov_mark::hit!(issue9358_bad_macro_stack_overflow);
311 Some(arg.green().into())
314 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<TokenExpander>> {
316 MacroDefKind::Declarative(ast_id) => match ast_id.to_node(db) {
317 ast::Macro::MacroRules(macro_rules) => {
318 let arg = macro_rules.token_tree()?;
319 let (tt, def_site_token_map) = mbe::syntax_node_to_token_tree(arg.syntax());
320 let mac = match mbe::MacroRules::parse(&tt) {
323 let name = macro_rules.name().map(|n| n.to_string()).unwrap_or_default();
324 tracing::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
328 Some(Arc::new(TokenExpander::MacroRules { mac, def_site_token_map }))
330 ast::Macro::MacroDef(macro_def) => {
331 let arg = macro_def.body()?;
332 let (tt, def_site_token_map) = mbe::syntax_node_to_token_tree(arg.syntax());
333 let mac = match mbe::MacroDef::parse(&tt) {
336 let name = macro_def.name().map(|n| n.to_string()).unwrap_or_default();
337 tracing::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
341 Some(Arc::new(TokenExpander::MacroDef { mac, def_site_token_map }))
344 MacroDefKind::BuiltIn(expander, _) => Some(Arc::new(TokenExpander::Builtin(expander))),
345 MacroDefKind::BuiltInAttr(expander, _) => {
346 Some(Arc::new(TokenExpander::BuiltinAttr(expander)))
348 MacroDefKind::BuiltInDerive(expander, _) => {
349 Some(Arc::new(TokenExpander::BuiltinDerive(expander)))
351 MacroDefKind::BuiltInEager(..) => None,
352 MacroDefKind::ProcMacro(expander, ..) => Some(Arc::new(TokenExpander::ProcMacro(expander))),
356 fn macro_expand(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>> {
357 let _p = profile::span("macro_expand");
358 let loc: MacroCallLoc = db.lookup_intern_macro(id);
359 if let Some(eager) = &loc.eager {
360 return ExpandResult {
361 value: Some(eager.arg_or_expansion.clone()),
362 // FIXME: There could be errors here!
367 let macro_arg = match db.macro_arg(id) {
369 None => return ExpandResult::str_err("Fail to args in to tt::TokenTree".into()),
372 let macro_rules = match db.macro_def(loc.def) {
374 None => return ExpandResult::str_err("Fail to find macro definition".into()),
376 let ExpandResult { value: tt, err } = macro_rules.expand(db, id, ¯o_arg.0);
377 // Set a hard limit for the expanded tt
378 let count = tt.count();
379 // XXX: Make ExpandResult a real error and use .map_err instead?
380 if TOKEN_LIMIT.check(count).is_err() {
381 return ExpandResult::str_err(format!(
382 "macro invocation exceeds token limit: produced {} tokens, limit is {}",
388 ExpandResult { value: Some(Arc::new(tt)), err }
391 fn macro_expand_error(db: &dyn AstDatabase, macro_call: MacroCallId) -> Option<ExpandError> {
392 db.macro_expand(macro_call).err
395 fn expand_proc_macro(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<tt::Subtree> {
396 let loc: MacroCallLoc = db.lookup_intern_macro(id);
397 let macro_arg = match db.macro_arg(id) {
399 None => return ExpandResult::str_err("No arguments for proc-macro".to_string()),
402 let expander = match loc.def.kind {
403 MacroDefKind::ProcMacro(expander, ..) => expander,
407 let attr_arg = match &loc.kind {
408 MacroCallKind::Attr { attr_args, .. } => {
409 let mut attr_args = attr_args.0.clone();
410 mbe::Shift::new(¯o_arg.0).shift_all(&mut attr_args);
416 expander.expand(db, loc.krate, ¯o_arg.0, attr_arg.as_ref())
419 fn is_self_replicating(from: &SyntaxNode, to: &SyntaxNode) -> bool {
420 if diff(from, to).is_empty() {
423 if let Some(stmts) = ast::MacroStmts::cast(from.clone()) {
424 if stmts.statements().any(|stmt| diff(stmt.syntax(), to).is_empty()) {
427 if let Some(expr) = stmts.expr() {
428 if diff(expr.syntax(), to).is_empty() {
436 fn hygiene_frame(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<HygieneFrame> {
437 Arc::new(HygieneFrame::new(db, file_id))
440 fn macro_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
441 let loc: MacroCallLoc = db.lookup_intern_macro(id);
442 loc.kind.fragment_kind()