crates/hir_expand/src/db.rs

   1 //! Defines database & queries for macro expansion.
   2
   3 use std::sync::Arc;
   4
   5 use base_db::{salsa, SourceDatabase};
   6 use mbe::{ExpandError, ExpandResult, MacroDef, MacroRules};
   7 use parser::FragmentKind;
   8 use syntax::{
   9     algo::diff,
  10     ast::{MacroStmts, NameOwner},
  11     AstNode, GreenNode, Parse,
  12     SyntaxKind::*,
  13     SyntaxNode,
  14 };
  15
  16 use crate::{
  17     ast_id_map::AstIdMap, hygiene::HygieneFrame, BuiltinDeriveExpander, BuiltinFnLikeExpander,
  18     EagerCallLoc, EagerMacroId, HirFileId, HirFileIdRepr, LazyMacroId, MacroCallId, MacroCallLoc,
  19     MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander,
  20 };
  21
  22 /// Total limit on the number of tokens produced by any macro invocation.
  23 ///
  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.
  26 const TOKEN_LIMIT: usize = 524288;
  27
  28 #[derive(Debug, Clone, Eq, PartialEq)]
  29 pub enum TokenExpander {
  30     MacroRules(mbe::MacroRules),
  31     MacroDef(mbe::MacroDef),
  32     Builtin(BuiltinFnLikeExpander),
  33     BuiltinDerive(BuiltinDeriveExpander),
  34     ProcMacro(ProcMacroExpander),
  35 }
  36
  37 impl TokenExpander {
  38     pub fn expand(
  39         &self,
  40         db: &dyn AstDatabase,
  41         id: LazyMacroId,
  42         tt: &tt::Subtree,
  43     ) -> mbe::ExpandResult<tt::Subtree> {
  44         match self {
  45             TokenExpander::MacroRules(it) => it.expand(tt),
  46             TokenExpander::MacroDef(it) => it.expand(tt),
  47             TokenExpander::Builtin(it) => it.expand(db, id, tt),
  48             // FIXME switch these to ExpandResult as well
  49             TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt).into(),
  50             TokenExpander::ProcMacro(_) => {
  51                 // We store the result in salsa db to prevent non-deterministic behavior in
  52                 // some proc-macro implementation
  53                 // See #4315 for details
  54                 db.expand_proc_macro(id.into()).into()
  55             }
  56         }
  57     }
  58
  59     pub fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
  60         match self {
  61             TokenExpander::MacroRules(it) => it.map_id_down(id),
  62             TokenExpander::MacroDef(it) => it.map_id_down(id),
  63             TokenExpander::Builtin(..) => id,
  64             TokenExpander::BuiltinDerive(..) => id,
  65             TokenExpander::ProcMacro(..) => id,
  66         }
  67     }
  68
  69     pub fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, mbe::Origin) {
  70         match self {
  71             TokenExpander::MacroRules(it) => it.map_id_up(id),
  72             TokenExpander::MacroDef(it) => it.map_id_up(id),
  73             TokenExpander::Builtin(..) => (id, mbe::Origin::Call),
  74             TokenExpander::BuiltinDerive(..) => (id, mbe::Origin::Call),
  75             TokenExpander::ProcMacro(..) => (id, mbe::Origin::Call),
  76         }
  77     }
  78 }
  79
  80 // FIXME: rename to ExpandDatabase
  81 #[salsa::query_group(AstDatabaseStorage)]
  82 pub trait AstDatabase: SourceDatabase {
  83     fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
  84
  85     #[salsa::transparent]
  86     fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
  87
  88     #[salsa::interned]
  89     fn intern_macro(&self, macro_call: MacroCallLoc) -> LazyMacroId;
  90     fn macro_arg_text(&self, id: MacroCallId) -> Option<GreenNode>;
  91     #[salsa::transparent]
  92     fn macro_arg(&self, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>>;
  93     fn macro_def(&self, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>>;
  94     fn parse_macro_expansion(
  95         &self,
  96         macro_file: MacroFile,
  97     ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>>;
  98     fn macro_expand(&self, macro_call: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>>;
  99
 100     /// Firewall query that returns the error from the `macro_expand` query.
 101     fn macro_expand_error(&self, macro_call: MacroCallId) -> Option<ExpandError>;
 102
 103     #[salsa::interned]
 104     fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
 105
 106     fn expand_proc_macro(&self, call: MacroCallId) -> Result<tt::Subtree, mbe::ExpandError>;
 107
 108     fn hygiene_frame(&self, file_id: HirFileId) -> Arc<HygieneFrame>;
 109 }
 110
 111 /// This expands the given macro call, but with different arguments. This is
 112 /// used for completion, where we want to see what 'would happen' if we insert a
 113 /// token. The `token_to_map` mapped down into the expansion, with the mapped
 114 /// token returned.
 115 pub fn expand_hypothetical(
 116     db: &dyn AstDatabase,
 117     actual_macro_call: MacroCallId,
 118     hypothetical_args: &syntax::ast::TokenTree,
 119     token_to_map: syntax::SyntaxToken,
 120 ) -> Option<(SyntaxNode, syntax::SyntaxToken)> {
 121     let macro_file = MacroFile { macro_call_id: actual_macro_call };
 122     let (tt, tmap_1) = mbe::syntax_node_to_token_tree(hypothetical_args.syntax()).unwrap();
 123     let range =
 124         token_to_map.text_range().checked_sub(hypothetical_args.syntax().text_range().start())?;
 125     let token_id = tmap_1.token_by_range(range)?;
 126     let macro_def = expander(db, actual_macro_call)?;
 127     let (node, tmap_2) =
 128         parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1)))).value?;
 129     let token_id = macro_def.0.map_id_down(token_id);
 130     let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
 131     let token = node.syntax_node().covering_element(range).into_token()?;
 132     Some((node.syntax_node(), token))
 133 }
 134
 135 fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
 136     let map =
 137         db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
 138     Arc::new(map)
 139 }
 140
 141 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
 142     match id.kind {
 143         MacroDefKind::Declarative(ast_id) => match ast_id.to_node(db) {
 144             syntax::ast::Macro::MacroRules(macro_rules) => {
 145                 let arg = macro_rules.token_tree()?;
 146                 let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
 147                     log::warn!("fail on macro_rules to token tree: {:#?}", arg);
 148                     None
 149                 })?;
 150                 let rules = match MacroRules::parse(&tt) {
 151                     Ok(it) => it,
 152                     Err(err) => {
 153                         let name = macro_rules.name().map(|n| n.to_string()).unwrap_or_default();
 154                         log::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
 155                         return None;
 156                     }
 157                 };
 158                 Some(Arc::new((TokenExpander::MacroRules(rules), tmap)))
 159             }
 160             syntax::ast::Macro::MacroDef(macro_def) => {
 161                 let arg = macro_def.body()?;
 162                 let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
 163                     log::warn!("fail on macro_def to token tree: {:#?}", arg);
 164                     None
 165                 })?;
 166                 let rules = match MacroDef::parse(&tt) {
 167                     Ok(it) => it,
 168                     Err(err) => {
 169                         let name = macro_def.name().map(|n| n.to_string()).unwrap_or_default();
 170                         log::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
 171                         return None;
 172                     }
 173                 };
 174                 Some(Arc::new((TokenExpander::MacroDef(rules), tmap)))
 175             }
 176         },
 177         MacroDefKind::BuiltIn(expander, _) => {
 178             Some(Arc::new((TokenExpander::Builtin(expander), mbe::TokenMap::default())))
 179         }
 180         MacroDefKind::BuiltInDerive(expander, _) => {
 181             Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
 182         }
 183         MacroDefKind::BuiltInEager(..) => None,
 184         MacroDefKind::ProcMacro(expander, ..) => {
 185             Some(Arc::new((TokenExpander::ProcMacro(expander), mbe::TokenMap::default())))
 186         }
 187     }
 188 }
 189
 190 fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
 191     let id = match id {
 192         MacroCallId::LazyMacro(id) => id,
 193         MacroCallId::EagerMacro(_id) => {
 194             // FIXME: support macro_arg for eager macro
 195             return None;
 196         }
 197     };
 198     let loc = db.lookup_intern_macro(id);
 199     let arg = loc.kind.arg(db)?;
 200     Some(arg.green())
 201 }
 202
 203 fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
 204     let arg = db.macro_arg_text(id)?;
 205     let (tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg))?;
 206     Some(Arc::new((tt, tmap)))
 207 }
 208
 209 fn macro_expand(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>> {
 210     macro_expand_with_arg(db, id, None)
 211 }
 212
 213 fn macro_expand_error(db: &dyn AstDatabase, macro_call: MacroCallId) -> Option<ExpandError> {
 214     db.macro_expand(macro_call).err
 215 }
 216
 217 fn expander(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
 218     let lazy_id = match id {
 219         MacroCallId::LazyMacro(id) => id,
 220         MacroCallId::EagerMacro(_id) => {
 221             return None;
 222         }
 223     };
 224
 225     let loc = db.lookup_intern_macro(lazy_id);
 226     let macro_rules = db.macro_def(loc.def)?;
 227     Some(macro_rules)
 228 }
 229
 230 fn macro_expand_with_arg(
 231     db: &dyn AstDatabase,
 232     id: MacroCallId,
 233     arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
 234 ) -> ExpandResult<Option<Arc<tt::Subtree>>> {
 235     let _p = profile::span("macro_expand");
 236     let lazy_id = match id {
 237         MacroCallId::LazyMacro(id) => id,
 238         MacroCallId::EagerMacro(id) => {
 239             if arg.is_some() {
 240                 return ExpandResult::str_err(
 241                     "hypothetical macro expansion not implemented for eager macro".to_owned(),
 242                 );
 243             } else {
 244                 return ExpandResult {
 245                     value: Some(db.lookup_intern_eager_expansion(id).subtree),
 246                     // FIXME: There could be errors here!
 247                     err: None,
 248                 };
 249             }
 250         }
 251     };
 252
 253     let loc = db.lookup_intern_macro(lazy_id);
 254     let macro_arg = match arg.or_else(|| db.macro_arg(id)) {
 255         Some(it) => it,
 256         None => return ExpandResult::str_err("Fail to args in to tt::TokenTree".into()),
 257     };
 258
 259     let macro_rules = match db.macro_def(loc.def) {
 260         Some(it) => it,
 261         None => return ExpandResult::str_err("Fail to find macro definition".into()),
 262     };
 263     let ExpandResult { value: tt, err } = macro_rules.0.expand(db, lazy_id, &macro_arg.0);
 264     // Set a hard limit for the expanded tt
 265     let count = tt.count();
 266     if count > TOKEN_LIMIT {
 267         return ExpandResult::str_err(format!(
 268             "macro invocation exceeds token limit: produced {} tokens, limit is {}",
 269             count, TOKEN_LIMIT,
 270         ));
 271     }
 272
 273     ExpandResult { value: Some(Arc::new(tt)), err }
 274 }
 275
 276 fn expand_proc_macro(
 277     db: &dyn AstDatabase,
 278     id: MacroCallId,
 279 ) -> Result<tt::Subtree, mbe::ExpandError> {
 280     let lazy_id = match id {
 281         MacroCallId::LazyMacro(id) => id,
 282         MacroCallId::EagerMacro(_) => unreachable!(),
 283     };
 284
 285     let loc = db.lookup_intern_macro(lazy_id);
 286     let macro_arg = match db.macro_arg(id) {
 287         Some(it) => it,
 288         None => {
 289             return Err(
 290                 tt::ExpansionError::Unknown("No arguments for proc-macro".to_string()).into()
 291             )
 292         }
 293     };
 294
 295     let expander = match loc.def.kind {
 296         MacroDefKind::ProcMacro(expander, ..) => expander,
 297         _ => unreachable!(),
 298     };
 299
 300     expander.expand(db, loc.krate, &macro_arg.0)
 301 }
 302
 303 fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
 304     match file_id.0 {
 305         HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
 306         HirFileIdRepr::MacroFile(macro_file) => {
 307             db.parse_macro_expansion(macro_file).value.map(|(it, _)| it.syntax_node())
 308         }
 309     }
 310 }
 311
 312 fn parse_macro_expansion(
 313     db: &dyn AstDatabase,
 314     macro_file: MacroFile,
 315 ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
 316     parse_macro_with_arg(db, macro_file, None)
 317 }
 318
 319 fn parse_macro_with_arg(
 320     db: &dyn AstDatabase,
 321     macro_file: MacroFile,
 322     arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
 323 ) -> ExpandResult<Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)>> {
 324     let macro_call_id = macro_file.macro_call_id;
 325     let result = if let Some(arg) = arg {
 326         macro_expand_with_arg(db, macro_call_id, Some(arg))
 327     } else {
 328         db.macro_expand(macro_call_id)
 329     };
 330
 331     let _p = profile::span("parse_macro_expansion");
 332
 333     if let Some(err) = &result.err {
 334         // Note:
 335         // The final goal we would like to make all parse_macro success,
 336         // such that the following log will not call anyway.
 337         match macro_call_id {
 338             MacroCallId::LazyMacro(id) => {
 339                 let loc: MacroCallLoc = db.lookup_intern_macro(id);
 340                 let node = loc.kind.node(db);
 341
 342                 // collect parent information for warning log
 343                 let parents = std::iter::successors(loc.kind.file_id().call_node(db), |it| {
 344                     it.file_id.call_node(db)
 345                 })
 346                 .map(|n| format!("{:#}", n.value))
 347                 .collect::<Vec<_>>()
 348                 .join("\n");
 349
 350                 log::warn!(
 351                     "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
 352                     err,
 353                     node.value,
 354                     parents
 355                 );
 356             }
 357             _ => {
 358                 log::warn!("fail on macro_parse: (reason: {:?})", err);
 359             }
 360         }
 361     }
 362     let tt = match result.value {
 363         Some(tt) => tt,
 364         None => return ExpandResult { value: None, err: result.err },
 365     };
 366
 367     let fragment_kind = to_fragment_kind(db, macro_call_id);
 368
 369     log::debug!("expanded = {}", tt.as_debug_string());
 370     log::debug!("kind = {:?}", fragment_kind);
 371
 372     let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
 373         Ok(it) => it,
 374         Err(err) => {
 375             log::debug!(
 376                 "failed to parse expanstion to {:?} = {}",
 377                 fragment_kind,
 378                 tt.as_debug_string()
 379             );
 380             return ExpandResult::only_err(err);
 381         }
 382     };
 383
 384     match result.err {
 385         Some(err) => {
 386             // Safety check for recursive identity macro.
 387             let node = parse.syntax_node();
 388             let file: HirFileId = macro_file.into();
 389             let call_node = match file.call_node(db) {
 390                 Some(it) => it,
 391                 None => {
 392                     return ExpandResult::only_err(err);
 393                 }
 394             };
 395             if is_self_replicating(&node, &call_node.value) {
 396                 return ExpandResult::only_err(err);
 397             } else {
 398                 ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
 399             }
 400         }
 401         None => {
 402             log::debug!("parse = {:?}", parse.syntax_node().kind());
 403             ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None }
 404         }
 405     }
 406 }
 407
 408 fn is_self_replicating(from: &SyntaxNode, to: &SyntaxNode) -> bool {
 409     if diff(from, to).is_empty() {
 410         return true;
 411     }
 412     if let Some(stmts) = MacroStmts::cast(from.clone()) {
 413         if stmts.statements().any(|stmt| diff(stmt.syntax(), to).is_empty()) {
 414             return true;
 415         }
 416         if let Some(expr) = stmts.expr() {
 417             if diff(expr.syntax(), to).is_empty() {
 418                 return true;
 419             }
 420         }
 421     }
 422     false
 423 }
 424
 425 fn hygiene_frame(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<HygieneFrame> {
 426     Arc::new(HygieneFrame::new(db, file_id))
 427 }
 428
 429 /// Given a `MacroCallId`, return what `FragmentKind` it belongs to.
 430 /// FIXME: Not completed
 431 fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
 432     let lazy_id = match id {
 433         MacroCallId::LazyMacro(id) => id,
 434         MacroCallId::EagerMacro(id) => {
 435             return db.lookup_intern_eager_expansion(id).fragment;
 436         }
 437     };
 438     let syn = db.lookup_intern_macro(lazy_id).kind.node(db).value;
 439
 440     let parent = match syn.parent() {
 441         Some(it) => it,
 442         None => return FragmentKind::Statements,
 443     };
 444
 445     match parent.kind() {
 446         MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
 447         MACRO_STMTS => FragmentKind::Statements,
 448         ITEM_LIST => FragmentKind::Items,
 449         LET_STMT => {
 450             // FIXME: Handle LHS Pattern
 451             FragmentKind::Expr
 452         }
 453         EXPR_STMT => FragmentKind::Statements,
 454         BLOCK_EXPR => FragmentKind::Statements,
 455         ARG_LIST => FragmentKind::Expr,
 456         TRY_EXPR => FragmentKind::Expr,
 457         TUPLE_EXPR => FragmentKind::Expr,
 458         PAREN_EXPR => FragmentKind::Expr,
 459         ARRAY_EXPR => FragmentKind::Expr,
 460         FOR_EXPR => FragmentKind::Expr,
 461         PATH_EXPR => FragmentKind::Expr,
 462         CLOSURE_EXPR => FragmentKind::Expr,
 463         CONDITION => FragmentKind::Expr,
 464         BREAK_EXPR => FragmentKind::Expr,
 465         RETURN_EXPR => FragmentKind::Expr,
 466         MATCH_EXPR => FragmentKind::Expr,
 467         MATCH_ARM => FragmentKind::Expr,
 468         MATCH_GUARD => FragmentKind::Expr,
 469         RECORD_EXPR_FIELD => FragmentKind::Expr,
 470         CALL_EXPR => FragmentKind::Expr,
 471         INDEX_EXPR => FragmentKind::Expr,
 472         METHOD_CALL_EXPR => FragmentKind::Expr,
 473         FIELD_EXPR => FragmentKind::Expr,
 474         AWAIT_EXPR => FragmentKind::Expr,
 475         CAST_EXPR => FragmentKind::Expr,
 476         REF_EXPR => FragmentKind::Expr,
 477         PREFIX_EXPR => FragmentKind::Expr,
 478         RANGE_EXPR => FragmentKind::Expr,
 479         BIN_EXPR => FragmentKind::Expr,
 480         _ => {
 481             // Unknown , Just guess it is `Items`
 482             FragmentKind::Items
 483         }
 484     }
 485 }