1 //! Defines database & queries for macro expansion.
5 use base_db::{salsa, SourceDatabase};
8 use mbe::{syntax_node_to_token_tree, ExpandError, ExpandResult};
9 use rustc_hash::FxHashSet;
12 ast::{self, HasAttrs, HasDocComments},
13 AstNode, GreenNode, Parse, SyntaxNode, SyntaxToken, T,
17 ast_id_map::AstIdMap, fixup, hygiene::HygieneFrame, BuiltinAttrExpander, BuiltinDeriveExpander,
18 BuiltinFnLikeExpander, ExpandTo, HirFileId, HirFileIdRepr, MacroCallId, MacroCallKind,
19 MacroCallLoc, 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` or the new macros 2.0
33 DeclarativeMacro { mac: mbe::DeclarativeMacro, def_site_token_map: mbe::TokenMap },
34 /// Stuff like `line!` and `file!`.
35 Builtin(BuiltinFnLikeExpander),
36 /// `global_allocator` and such.
37 BuiltinAttr(BuiltinAttrExpander),
38 /// `derive(Copy)` and such.
39 BuiltinDerive(BuiltinDeriveExpander),
40 /// The thing we love the most here in rust-analyzer -- procedural macros.
41 ProcMacro(ProcMacroExpander),
50 ) -> mbe::ExpandResult<tt::Subtree> {
52 TokenExpander::DeclarativeMacro { mac, .. } => mac.expand(tt),
53 TokenExpander::Builtin(it) => it.expand(db, id, tt),
54 TokenExpander::BuiltinAttr(it) => it.expand(db, id, tt),
55 TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt),
56 TokenExpander::ProcMacro(_) => {
57 // We store the result in salsa db to prevent non-deterministic behavior in
58 // some proc-macro implementation
59 // See #4315 for details
60 db.expand_proc_macro(id)
65 pub(crate) fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
67 TokenExpander::DeclarativeMacro { mac, .. } => mac.map_id_down(id),
68 TokenExpander::Builtin(..)
69 | TokenExpander::BuiltinAttr(..)
70 | TokenExpander::BuiltinDerive(..)
71 | TokenExpander::ProcMacro(..) => id,
75 pub(crate) fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, mbe::Origin) {
77 TokenExpander::DeclarativeMacro { mac, .. } => mac.map_id_up(id),
78 TokenExpander::Builtin(..)
79 | TokenExpander::BuiltinAttr(..)
80 | TokenExpander::BuiltinDerive(..)
81 | TokenExpander::ProcMacro(..) => (id, mbe::Origin::Call),
86 // FIXME: rename to ExpandDatabase
87 #[salsa::query_group(AstDatabaseStorage)]
88 pub trait AstDatabase: SourceDatabase {
89 fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
91 /// Main public API -- parses a hir file, not caring whether it's a real
92 /// file or a macro expansion.
94 fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
95 /// Implementation for the macro case.
96 fn parse_macro_expansion(
98 macro_file: MacroFile,
99 ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>>;
101 /// Macro ids. That's probably the tricksiest bit in rust-analyzer, and the
102 /// reason why we use salsa at all.
104 /// We encode macro definitions into ids of macro calls, this what allows us
105 /// to be incremental.
107 fn intern_macro_call(&self, macro_call: MacroCallLoc) -> MacroCallId;
109 /// Lowers syntactic macro call to a token tree representation.
110 #[salsa::transparent]
114 ) -> Option<Arc<(tt::Subtree, mbe::TokenMap, fixup::SyntaxFixupUndoInfo)>>;
115 /// Extracts syntax node, corresponding to a macro call. That's a firewall
116 /// query, only typing in the macro call itself changes the returned
118 fn macro_arg_text(&self, id: MacroCallId) -> Option<GreenNode>;
119 /// Gets the expander for this macro. This compiles declarative macros, and
120 /// just fetches procedural ones.
121 fn macro_def(&self, id: MacroDefId) -> Result<Arc<TokenExpander>, mbe::ParseError>;
123 /// Expand macro call to a token tree. This query is LRUed (we keep 128 or so results in memory)
124 fn macro_expand(&self, macro_call: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>>;
125 /// Special case of the previous query for procedural macros. We can't LRU
126 /// proc macros, since they are not deterministic in general, and
127 /// non-determinism breaks salsa in a very, very, very bad way. @edwin0cheng
128 /// heroically debugged this once!
129 fn expand_proc_macro(&self, call: MacroCallId) -> ExpandResult<tt::Subtree>;
130 /// Firewall query that returns the error from the `macro_expand` query.
131 fn macro_expand_error(&self, macro_call: MacroCallId) -> Option<ExpandError>;
133 fn hygiene_frame(&self, file_id: HirFileId) -> Arc<HygieneFrame>;
136 /// This expands the given macro call, but with different arguments. This is
137 /// used for completion, where we want to see what 'would happen' if we insert a
138 /// token. The `token_to_map` mapped down into the expansion, with the mapped
140 pub fn expand_speculative(
141 db: &dyn AstDatabase,
142 actual_macro_call: MacroCallId,
143 speculative_args: &SyntaxNode,
144 token_to_map: SyntaxToken,
145 ) -> Option<(SyntaxNode, SyntaxToken)> {
146 let loc = db.lookup_intern_macro_call(actual_macro_call);
147 let macro_def = db.macro_def(loc.def).ok()?;
148 let token_range = token_to_map.text_range();
150 // Build the subtree and token mapping for the speculative args
151 let censor = censor_for_macro_input(&loc, &speculative_args);
152 let mut fixups = fixup::fixup_syntax(&speculative_args);
153 fixups.replace.extend(censor.into_iter().map(|node| (node, Vec::new())));
154 let (mut tt, spec_args_tmap, _) = mbe::syntax_node_to_token_tree_with_modifications(
162 let (attr_arg, token_id) = match loc.kind {
163 MacroCallKind::Attr { invoc_attr_index, .. } => {
164 // Attributes may have an input token tree, build the subtree and map for this as well
165 // then try finding a token id for our token if it is inside this input subtree.
166 let item = ast::Item::cast(speculative_args.clone())?;
168 .doc_comments_and_attrs()
169 .nth(invoc_attr_index as usize)
170 .and_then(Either::left)?;
171 match attr.token_tree() {
172 Some(token_tree) => {
173 let (mut tree, map) = syntax_node_to_token_tree(attr.token_tree()?.syntax());
174 tree.delimiter = None;
176 let shift = mbe::Shift::new(&tt);
177 shift.shift_all(&mut tree);
179 let token_id = if token_tree.syntax().text_range().contains_range(token_range) {
180 let attr_input_start =
181 token_tree.left_delimiter_token()?.text_range().start();
182 let range = token_range.checked_sub(attr_input_start)?;
183 let token_id = shift.shift(map.token_by_range(range)?);
188 (Some(tree), token_id)
195 let token_id = match token_id {
196 Some(token_id) => token_id,
197 // token wasn't inside an attribute input so it has to be in the general macro input
199 let range = token_range.checked_sub(speculative_args.text_range().start())?;
200 let token_id = spec_args_tmap.token_by_range(range)?;
201 macro_def.map_id_down(token_id)
205 // Do the actual expansion, we need to directly expand the proc macro due to the attribute args
206 // Otherwise the expand query will fetch the non speculative attribute args and pass those instead.
207 let mut speculative_expansion = if let MacroDefKind::ProcMacro(expander, ..) = loc.def.kind {
209 expander.expand(db, loc.krate, &tt, attr_arg.as_ref())
211 macro_def.expand(db, actual_macro_call, &tt)
214 let expand_to = macro_expand_to(db, actual_macro_call);
215 fixup::reverse_fixups(&mut speculative_expansion.value, &spec_args_tmap, &fixups.undo_info);
216 let (node, rev_tmap) = token_tree_to_syntax_node(&speculative_expansion.value, expand_to);
218 let range = rev_tmap.first_range_by_token(token_id, token_to_map.kind())?;
219 let token = node.syntax_node().covering_element(range).into_token()?;
220 Some((node.syntax_node(), token))
223 fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
224 let map = db.parse_or_expand(file_id).map(|it| AstIdMap::from_source(&it)).unwrap_or_default();
228 fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
230 HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
231 HirFileIdRepr::MacroFile(macro_file) => {
232 // FIXME: Note how we convert from `Parse` to `SyntaxNode` here,
233 // forgetting about parse errors.
234 db.parse_macro_expansion(macro_file).value.map(|(it, _)| it.syntax_node())
239 fn parse_macro_expansion(
240 db: &dyn AstDatabase,
241 macro_file: MacroFile,
242 ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
243 let _p = profile::span("parse_macro_expansion");
244 let result = db.macro_expand(macro_file.macro_call_id);
246 if let Some(err) = &result.err {
248 // The final goal we would like to make all parse_macro success,
249 // such that the following log will not call anyway.
250 let loc: MacroCallLoc = db.lookup_intern_macro_call(macro_file.macro_call_id);
251 let node = loc.kind.to_node(db);
253 // collect parent information for warning log
255 std::iter::successors(loc.kind.file_id().call_node(db), |it| it.file_id.call_node(db))
256 .map(|n| format!("{:#}", n.value))
261 "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
267 let tt = match result.value {
269 None => return ExpandResult { value: None, err: result.err },
272 let expand_to = macro_expand_to(db, macro_file.macro_call_id);
274 tracing::debug!("expanded = {}", tt.as_debug_string());
275 tracing::debug!("kind = {:?}", expand_to);
277 let (parse, rev_token_map) = token_tree_to_syntax_node(&tt, expand_to);
281 // Safety check for recursive identity macro.
282 let node = parse.syntax_node();
283 let file: HirFileId = macro_file.into();
284 let call_node = match file.call_node(db) {
287 return ExpandResult::only_err(err);
290 if is_self_replicating(&node, &call_node.value) {
291 ExpandResult::only_err(err)
293 ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
297 tracing::debug!("parse = {:?}", parse.syntax_node().kind());
298 ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None }
304 db: &dyn AstDatabase,
306 ) -> Option<Arc<(tt::Subtree, mbe::TokenMap, fixup::SyntaxFixupUndoInfo)>> {
307 let arg = db.macro_arg_text(id)?;
308 let loc = db.lookup_intern_macro_call(id);
310 let node = SyntaxNode::new_root(arg);
311 let censor = censor_for_macro_input(&loc, &node);
312 let mut fixups = fixup::fixup_syntax(&node);
313 fixups.replace.extend(censor.into_iter().map(|node| (node, Vec::new())));
314 let (mut tt, tmap, _) = mbe::syntax_node_to_token_tree_with_modifications(
322 if loc.def.is_proc_macro() {
323 // proc macros expect their inputs without parentheses, MBEs expect it with them included
327 Some(Arc::new((tt, tmap, fixups.undo_info)))
330 fn censor_for_macro_input(loc: &MacroCallLoc, node: &SyntaxNode) -> FxHashSet<SyntaxNode> {
332 let censor = match loc.kind {
333 MacroCallKind::FnLike { .. } => return None,
334 MacroCallKind::Derive { derive_attr_index, .. } => {
335 cov_mark::hit!(derive_censoring);
336 ast::Item::cast(node.clone())?
338 .take(derive_attr_index as usize + 1)
340 .filter(|attr| attr.simple_name().as_deref() == Some("derive"))
341 .map(|it| it.syntax().clone())
344 MacroCallKind::Attr { invoc_attr_index, .. } => {
345 cov_mark::hit!(attribute_macro_attr_censoring);
346 ast::Item::cast(node.clone())?
347 .doc_comments_and_attrs()
348 .nth(invoc_attr_index as usize)
349 .and_then(Either::left)
350 .map(|attr| attr.syntax().clone())
360 fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
361 let loc = db.lookup_intern_macro_call(id);
362 let arg = loc.kind.arg(db)?;
363 if matches!(loc.kind, MacroCallKind::FnLike { .. }) {
364 let first = arg.first_child_or_token().map_or(T![.], |it| it.kind());
365 let last = arg.last_child_or_token().map_or(T![.], |it| it.kind());
367 matches!((first, last), (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']));
369 // Don't expand malformed (unbalanced) macro invocations. This is
370 // less than ideal, but trying to expand unbalanced macro calls
371 // sometimes produces pathological, deeply nested code which breaks
372 // all kinds of things.
374 // Some day, we'll have explicit recursion counters for all
375 // recursive things, at which point this code might be removed.
376 cov_mark::hit!(issue9358_bad_macro_stack_overflow);
380 Some(arg.green().into())
383 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Result<Arc<TokenExpander>, mbe::ParseError> {
385 MacroDefKind::Declarative(ast_id) => {
386 let (mac, def_site_token_map) = match ast_id.to_node(db) {
387 ast::Macro::MacroRules(macro_rules) => {
388 let arg = macro_rules
390 .ok_or_else(|| mbe::ParseError::Expected("expected a token tree".into()))?;
391 let (tt, def_site_token_map) = mbe::syntax_node_to_token_tree(arg.syntax());
392 let mac = mbe::DeclarativeMacro::parse_macro_rules(&tt)?;
393 (mac, def_site_token_map)
395 ast::Macro::MacroDef(macro_def) => {
398 .ok_or_else(|| mbe::ParseError::Expected("expected a token tree".into()))?;
399 let (tt, def_site_token_map) = mbe::syntax_node_to_token_tree(arg.syntax());
400 let mac = mbe::DeclarativeMacro::parse_macro2(&tt)?;
401 (mac, def_site_token_map)
404 Ok(Arc::new(TokenExpander::DeclarativeMacro { mac, def_site_token_map }))
406 MacroDefKind::BuiltIn(expander, _) => Ok(Arc::new(TokenExpander::Builtin(expander))),
407 MacroDefKind::BuiltInAttr(expander, _) => {
408 Ok(Arc::new(TokenExpander::BuiltinAttr(expander)))
410 MacroDefKind::BuiltInDerive(expander, _) => {
411 Ok(Arc::new(TokenExpander::BuiltinDerive(expander)))
413 MacroDefKind::BuiltInEager(..) => {
414 // FIXME: Return a random error here just to make the types align.
415 // This obviously should do something real instead.
416 Err(mbe::ParseError::UnexpectedToken("unexpected eager macro".into()))
418 MacroDefKind::ProcMacro(expander, ..) => Ok(Arc::new(TokenExpander::ProcMacro(expander))),
422 fn macro_expand(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>> {
423 let _p = profile::span("macro_expand");
424 let loc: MacroCallLoc = db.lookup_intern_macro_call(id);
425 if let Some(eager) = &loc.eager {
426 return ExpandResult {
427 value: Some(eager.arg_or_expansion.clone()),
428 // FIXME: There could be errors here!
433 let macro_arg = match db.macro_arg(id) {
435 None => return ExpandResult::str_err("Failed to lower macro args to token tree".into()),
438 let expander = match db.macro_def(loc.def) {
440 // FIXME: This is weird -- we effectively report macro *definition*
441 // errors lazily, when we try to expand the macro. Instead, they should
442 // be reported at the definition site (when we construct a def map).
443 Err(err) => return ExpandResult::str_err(format!("invalid macro definition: {}", err)),
445 let ExpandResult { value: mut tt, err } = expander.expand(db, id, ¯o_arg.0);
446 // Set a hard limit for the expanded tt
447 let count = tt.count();
448 if TOKEN_LIMIT.check(count).is_err() {
449 return ExpandResult::str_err(format!(
450 "macro invocation exceeds token limit: produced {} tokens, limit is {}",
456 fixup::reverse_fixups(&mut tt, ¯o_arg.1, ¯o_arg.2);
458 ExpandResult { value: Some(Arc::new(tt)), err }
461 fn macro_expand_error(db: &dyn AstDatabase, macro_call: MacroCallId) -> Option<ExpandError> {
462 db.macro_expand(macro_call).err
465 fn expand_proc_macro(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<tt::Subtree> {
466 let loc: MacroCallLoc = db.lookup_intern_macro_call(id);
467 let macro_arg = match db.macro_arg(id) {
469 None => return ExpandResult::str_err("No arguments for proc-macro".to_string()),
472 let expander = match loc.def.kind {
473 MacroDefKind::ProcMacro(expander, ..) => expander,
477 let attr_arg = match &loc.kind {
478 MacroCallKind::Attr { attr_args, .. } => {
479 let mut attr_args = attr_args.0.clone();
480 mbe::Shift::new(¯o_arg.0).shift_all(&mut attr_args);
486 expander.expand(db, loc.krate, ¯o_arg.0, attr_arg.as_ref())
489 fn is_self_replicating(from: &SyntaxNode, to: &SyntaxNode) -> bool {
490 if diff(from, to).is_empty() {
493 if let Some(stmts) = ast::MacroStmts::cast(from.clone()) {
494 if stmts.statements().any(|stmt| diff(stmt.syntax(), to).is_empty()) {
497 if let Some(expr) = stmts.expr() {
498 if diff(expr.syntax(), to).is_empty() {
506 fn hygiene_frame(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<HygieneFrame> {
507 Arc::new(HygieneFrame::new(db, file_id))
510 fn macro_expand_to(db: &dyn AstDatabase, id: MacroCallId) -> ExpandTo {
511 let loc: MacroCallLoc = db.lookup_intern_macro_call(id);
515 fn token_tree_to_syntax_node(
518 ) -> (Parse<SyntaxNode>, mbe::TokenMap) {
519 let entry_point = match expand_to {
520 ExpandTo::Statements => mbe::TopEntryPoint::MacroStmts,
521 ExpandTo::Items => mbe::TopEntryPoint::MacroItems,
522 ExpandTo::Pattern => mbe::TopEntryPoint::Pattern,
523 ExpandTo::Type => mbe::TopEntryPoint::Type,
524 ExpandTo::Expr => mbe::TopEntryPoint::Expr,
526 mbe::token_tree_to_syntax_node(tt, entry_point)