1 //! Defines database & queries for macro expansion.
5 use base_db::{salsa, SourceDatabase};
6 use mbe::{ExpandError, ExpandResult, MacroRules};
7 use parser::FragmentKind;
8 use syntax::{algo::diff, ast::NameOwner, AstNode, GreenNode, Parse, SyntaxKind::*, SyntaxNode};
11 ast_id_map::AstIdMap, hygiene::HygieneFrame, BuiltinDeriveExpander, BuiltinFnLikeExpander,
12 EagerCallLoc, EagerMacroId, HirFileId, HirFileIdRepr, LazyMacroId, MacroCallId, MacroCallLoc,
13 MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander,
16 /// Total limit on the number of tokens produced by any macro invocation.
18 /// If an invocation produces more tokens than this limit, it will not be stored in the database and
19 /// an error will be emitted.
20 const TOKEN_LIMIT: usize = 524288;
22 #[derive(Debug, Clone, Eq, PartialEq)]
23 pub enum TokenExpander {
24 MacroRules(mbe::MacroRules),
25 Builtin(BuiltinFnLikeExpander),
26 BuiltinDerive(BuiltinDeriveExpander),
27 ProcMacro(ProcMacroExpander),
36 ) -> mbe::ExpandResult<tt::Subtree> {
38 TokenExpander::MacroRules(it) => it.expand(tt),
39 TokenExpander::Builtin(it) => it.expand(db, id, tt),
40 // FIXME switch these to ExpandResult as well
41 TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt).into(),
42 TokenExpander::ProcMacro(_) => {
43 // We store the result in salsa db to prevent non-deterministic behavior in
44 // some proc-macro implementation
45 // See #4315 for details
46 db.expand_proc_macro(id.into()).into()
51 pub fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
53 TokenExpander::MacroRules(it) => it.map_id_down(id),
54 TokenExpander::Builtin(..) => id,
55 TokenExpander::BuiltinDerive(..) => id,
56 TokenExpander::ProcMacro(..) => id,
60 pub fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, mbe::Origin) {
62 TokenExpander::MacroRules(it) => it.map_id_up(id),
63 TokenExpander::Builtin(..) => (id, mbe::Origin::Call),
64 TokenExpander::BuiltinDerive(..) => (id, mbe::Origin::Call),
65 TokenExpander::ProcMacro(..) => (id, mbe::Origin::Call),
70 // FIXME: rename to ExpandDatabase
71 #[salsa::query_group(AstDatabaseStorage)]
72 pub trait AstDatabase: SourceDatabase {
73 fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
76 fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
79 fn intern_macro(&self, macro_call: MacroCallLoc) -> LazyMacroId;
80 fn macro_arg_text(&self, id: MacroCallId) -> Option<GreenNode>;
82 fn macro_arg(&self, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>>;
83 fn macro_def(&self, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>>;
84 fn parse_macro_expansion(
86 macro_file: MacroFile,
87 ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>>;
88 fn macro_expand(&self, macro_call: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>>;
90 /// Firewall query that returns the error from the `macro_expand` query.
91 fn macro_expand_error(&self, macro_call: MacroCallId) -> Option<ExpandError>;
94 fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
96 fn expand_proc_macro(&self, call: MacroCallId) -> Result<tt::Subtree, mbe::ExpandError>;
98 fn hygiene_frame(&self, file_id: HirFileId) -> Arc<HygieneFrame>;
101 /// This expands the given macro call, but with different arguments. This is
102 /// used for completion, where we want to see what 'would happen' if we insert a
103 /// token. The `token_to_map` mapped down into the expansion, with the mapped
105 pub fn expand_hypothetical(
106 db: &dyn AstDatabase,
107 actual_macro_call: MacroCallId,
108 hypothetical_args: &syntax::ast::TokenTree,
109 token_to_map: syntax::SyntaxToken,
110 ) -> Option<(SyntaxNode, syntax::SyntaxToken)> {
111 let macro_file = MacroFile { macro_call_id: actual_macro_call };
112 let (tt, tmap_1) = mbe::syntax_node_to_token_tree(hypothetical_args.syntax()).unwrap();
114 token_to_map.text_range().checked_sub(hypothetical_args.syntax().text_range().start())?;
115 let token_id = tmap_1.token_by_range(range)?;
116 let macro_def = expander(db, actual_macro_call)?;
118 parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1)))).value?;
119 let token_id = macro_def.0.map_id_down(token_id);
120 let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
121 let token = syntax::algo::find_covering_element(&node.syntax_node(), range).into_token()?;
122 Some((node.syntax_node(), token))
125 fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
127 db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
131 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
133 MacroDefKind::Declarative => {
134 let macro_rules = match id.ast_id?.to_node(db) {
135 syntax::ast::Macro::MacroRules(mac) => mac,
136 syntax::ast::Macro::MacroDef(_) => return None,
138 let arg = macro_rules.token_tree()?;
139 let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
140 log::warn!("fail on macro_def to token tree: {:#?}", arg);
143 let rules = match MacroRules::parse(&tt) {
146 let name = macro_rules.name().map(|n| n.to_string()).unwrap_or_default();
147 log::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
151 Some(Arc::new((TokenExpander::MacroRules(rules), tmap)))
153 MacroDefKind::BuiltIn(expander) => {
154 Some(Arc::new((TokenExpander::Builtin(expander), mbe::TokenMap::default())))
156 MacroDefKind::BuiltInDerive(expander) => {
157 Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
159 MacroDefKind::BuiltInEager(_) => None,
160 MacroDefKind::ProcMacro(expander) => {
161 Some(Arc::new((TokenExpander::ProcMacro(expander), mbe::TokenMap::default())))
166 fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
168 MacroCallId::LazyMacro(id) => id,
169 MacroCallId::EagerMacro(_id) => {
170 // FIXME: support macro_arg for eager macro
174 let loc = db.lookup_intern_macro(id);
175 let arg = loc.kind.arg(db)?;
176 Some(arg.green().clone())
179 fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
180 let arg = db.macro_arg_text(id)?;
181 let (tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg))?;
182 Some(Arc::new((tt, tmap)))
185 fn macro_expand(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>> {
186 macro_expand_with_arg(db, id, None)
189 fn macro_expand_error(db: &dyn AstDatabase, macro_call: MacroCallId) -> Option<ExpandError> {
190 db.macro_expand(macro_call).err
193 fn expander(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
194 let lazy_id = match id {
195 MacroCallId::LazyMacro(id) => id,
196 MacroCallId::EagerMacro(_id) => {
201 let loc = db.lookup_intern_macro(lazy_id);
202 let macro_rules = db.macro_def(loc.def)?;
206 fn macro_expand_with_arg(
207 db: &dyn AstDatabase,
209 arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
210 ) -> ExpandResult<Option<Arc<tt::Subtree>>> {
211 let _p = profile::span("macro_expand");
212 let lazy_id = match id {
213 MacroCallId::LazyMacro(id) => id,
214 MacroCallId::EagerMacro(id) => {
216 return ExpandResult::str_err(
217 "hypothetical macro expansion not implemented for eager macro".to_owned(),
220 return ExpandResult {
221 value: Some(db.lookup_intern_eager_expansion(id).subtree),
222 // FIXME: There could be errors here!
229 let loc = db.lookup_intern_macro(lazy_id);
230 let macro_arg = match arg.or_else(|| db.macro_arg(id)) {
232 None => return ExpandResult::str_err("Fail to args in to tt::TokenTree".into()),
235 let macro_rules = match db.macro_def(loc.def) {
237 None => return ExpandResult::str_err("Fail to find macro definition".into()),
239 let ExpandResult { value: tt, err } = macro_rules.0.expand(db, lazy_id, ¯o_arg.0);
240 // Set a hard limit for the expanded tt
241 let count = tt.count();
242 if count > TOKEN_LIMIT {
243 return ExpandResult::str_err(format!(
244 "macro invocation exceeds token limit: produced {} tokens, limit is {}",
249 ExpandResult { value: Some(Arc::new(tt)), err }
252 fn expand_proc_macro(
253 db: &dyn AstDatabase,
255 ) -> Result<tt::Subtree, mbe::ExpandError> {
256 let lazy_id = match id {
257 MacroCallId::LazyMacro(id) => id,
258 MacroCallId::EagerMacro(_) => unreachable!(),
261 let loc = db.lookup_intern_macro(lazy_id);
262 let macro_arg = match db.macro_arg(id) {
266 tt::ExpansionError::Unknown("No arguments for proc-macro".to_string()).into()
271 let expander = match loc.def.kind {
272 MacroDefKind::ProcMacro(expander) => expander,
276 expander.expand(db, loc.krate, ¯o_arg.0)
279 fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
281 HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
282 HirFileIdRepr::MacroFile(macro_file) => {
283 db.parse_macro_expansion(macro_file).value.map(|(it, _)| it.syntax_node())
288 fn parse_macro_expansion(
289 db: &dyn AstDatabase,
290 macro_file: MacroFile,
291 ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
292 parse_macro_with_arg(db, macro_file, None)
295 fn parse_macro_with_arg(
296 db: &dyn AstDatabase,
297 macro_file: MacroFile,
298 arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
299 ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
300 let macro_call_id = macro_file.macro_call_id;
301 let result = if let Some(arg) = arg {
302 macro_expand_with_arg(db, macro_call_id, Some(arg))
304 db.macro_expand(macro_call_id)
307 let _p = profile::span("parse_macro_expansion");
309 if let Some(err) = &result.err {
311 // The final goal we would like to make all parse_macro success,
312 // such that the following log will not call anyway.
313 match macro_call_id {
314 MacroCallId::LazyMacro(id) => {
315 let loc: MacroCallLoc = db.lookup_intern_macro(id);
316 let node = loc.kind.node(db);
318 // collect parent information for warning log
319 let parents = std::iter::successors(loc.kind.file_id().call_node(db), |it| {
320 it.file_id.call_node(db)
322 .map(|n| format!("{:#}", n.value))
327 "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
334 log::warn!("fail on macro_parse: (reason: {:?})", err);
338 let tt = match result.value {
340 None => return ExpandResult { value: None, err: result.err },
343 let fragment_kind = to_fragment_kind(db, macro_call_id);
345 let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
348 return ExpandResult::only_err(err);
354 // Safety check for recursive identity macro.
355 let node = parse.syntax_node();
356 let file: HirFileId = macro_file.into();
357 let call_node = match file.call_node(db) {
360 return ExpandResult::only_err(err);
364 if !diff(&node, &call_node.value).is_empty() {
365 ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
367 return ExpandResult::only_err(err);
370 None => ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None },
374 fn hygiene_frame(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<HygieneFrame> {
375 Arc::new(HygieneFrame::new(db, file_id))
378 /// Given a `MacroCallId`, return what `FragmentKind` it belongs to.
379 /// FIXME: Not completed
380 fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
381 let lazy_id = match id {
382 MacroCallId::LazyMacro(id) => id,
383 MacroCallId::EagerMacro(id) => {
384 return db.lookup_intern_eager_expansion(id).fragment;
387 let syn = db.lookup_intern_macro(lazy_id).kind.node(db).value;
389 let parent = match syn.parent() {
393 // If it is root, which means the parent HirFile
394 // MacroKindFile must be non-items
396 return FragmentKind::Expr;
400 match parent.kind() {
401 MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
402 ITEM_LIST => FragmentKind::Items,
404 // FIXME: Handle Pattern
407 EXPR_STMT => FragmentKind::Statements,
408 BLOCK_EXPR => FragmentKind::Expr,
409 ARG_LIST => FragmentKind::Expr,
410 TRY_EXPR => FragmentKind::Expr,
411 TUPLE_EXPR => FragmentKind::Expr,
412 PAREN_EXPR => FragmentKind::Expr,
413 ARRAY_EXPR => FragmentKind::Expr,
414 FOR_EXPR => FragmentKind::Expr,
415 PATH_EXPR => FragmentKind::Expr,
416 CLOSURE_EXPR => FragmentKind::Expr,
417 CONDITION => FragmentKind::Expr,
418 BREAK_EXPR => FragmentKind::Expr,
419 RETURN_EXPR => FragmentKind::Expr,
420 MATCH_EXPR => FragmentKind::Expr,
421 MATCH_ARM => FragmentKind::Expr,
422 MATCH_GUARD => FragmentKind::Expr,
423 RECORD_EXPR_FIELD => FragmentKind::Expr,
424 CALL_EXPR => FragmentKind::Expr,
425 INDEX_EXPR => FragmentKind::Expr,
426 METHOD_CALL_EXPR => FragmentKind::Expr,
427 FIELD_EXPR => FragmentKind::Expr,
428 AWAIT_EXPR => FragmentKind::Expr,
429 CAST_EXPR => FragmentKind::Expr,
430 REF_EXPR => FragmentKind::Expr,
431 PREFIX_EXPR => FragmentKind::Expr,
432 RANGE_EXPR => FragmentKind::Expr,
433 BIN_EXPR => FragmentKind::Expr,
435 // Unknown , Just guess it is `Items`