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, MacroRules};
   7 use parser::FragmentKind;
   8 use syntax::{algo::diff, ast::NameOwner, AstNode, GreenNode, Parse, SyntaxKind::*, SyntaxNode};
   9
  10 use crate::{
  11     ast_id_map::AstIdMap, hygiene::HygieneFrame, BuiltinDeriveExpander, BuiltinFnLikeExpander,
  12     EagerCallLoc, EagerMacroId, HirFileId, HirFileIdRepr, LazyMacroId, MacroCallId, MacroCallLoc,
  13     MacroDefId, MacroDefKind, MacroFile, ProcMacroExpander,
  14 };
  15
  16 /// Total limit on the number of tokens produced by any macro invocation.
  17 ///
  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;
  21
  22 #[derive(Debug, Clone, Eq, PartialEq)]
  23 pub enum TokenExpander {
  24     MacroRules(mbe::MacroRules),
  25     Builtin(BuiltinFnLikeExpander),
  26     BuiltinDerive(BuiltinDeriveExpander),
  27     ProcMacro(ProcMacroExpander),
  28 }
  29
  30 impl TokenExpander {
  31     pub fn expand(
  32         &self,
  33         db: &dyn AstDatabase,
  34         id: LazyMacroId,
  35         tt: &tt::Subtree,
  36     ) -> mbe::ExpandResult<tt::Subtree> {
  37         match self {
  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()
  47             }
  48         }
  49     }
  50
  51     pub fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
  52         match self {
  53             TokenExpander::MacroRules(it) => it.map_id_down(id),
  54             TokenExpander::Builtin(..) => id,
  55             TokenExpander::BuiltinDerive(..) => id,
  56             TokenExpander::ProcMacro(..) => id,
  57         }
  58     }
  59
  60     pub fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, mbe::Origin) {
  61         match self {
  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),
  66         }
  67     }
  68 }
  69
  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>;
  74
  75     #[salsa::transparent]
  76     fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
  77
  78     #[salsa::interned]
  79     fn intern_macro(&self, macro_call: MacroCallLoc) -> LazyMacroId;
  80     fn macro_arg_text(&self, id: MacroCallId) -> Option<GreenNode>;
  81     #[salsa::transparent]
  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(
  85         &self,
  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>>>;
  89
  90     /// Firewall query that returns the error from the `macro_expand` query.
  91     fn macro_expand_error(&self, macro_call: MacroCallId) -> Option<ExpandError>;
  92
  93     #[salsa::interned]
  94     fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
  95
  96     fn expand_proc_macro(&self, call: MacroCallId) -> Result<tt::Subtree, mbe::ExpandError>;
  97
  98     fn hygiene_frame(&self, file_id: HirFileId) -> Arc<HygieneFrame>;
  99 }
 100
 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
 104 /// token returned.
 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();
 113     let range =
 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)?;
 117     let (node, tmap_2) =
 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 = node.syntax_node().covering_element(range).into_token()?;
 122     Some((node.syntax_node(), token))
 123 }
 124
 125 fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
 126     let map =
 127         db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
 128     Arc::new(map)
 129 }
 130
 131 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
 132     match id.kind {
 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,
 137             };
 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);
 141                 None
 142             })?;
 143             let rules = match MacroRules::parse(&tt) {
 144                 Ok(it) => it,
 145                 Err(err) => {
 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);
 148                     return None;
 149                 }
 150             };
 151             Some(Arc::new((TokenExpander::MacroRules(rules), tmap)))
 152         }
 153         MacroDefKind::BuiltIn(expander) => {
 154             Some(Arc::new((TokenExpander::Builtin(expander), mbe::TokenMap::default())))
 155         }
 156         MacroDefKind::BuiltInDerive(expander) => {
 157             Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
 158         }
 159         MacroDefKind::BuiltInEager(_) => None,
 160         MacroDefKind::ProcMacro(expander) => {
 161             Some(Arc::new((TokenExpander::ProcMacro(expander), mbe::TokenMap::default())))
 162         }
 163     }
 164 }
 165
 166 fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
 167     let id = match id {
 168         MacroCallId::LazyMacro(id) => id,
 169         MacroCallId::EagerMacro(_id) => {
 170             // FIXME: support macro_arg for eager macro
 171             return None;
 172         }
 173     };
 174     let loc = db.lookup_intern_macro(id);
 175     let arg = loc.kind.arg(db)?;
 176     Some(arg.green().to_owned())
 177 }
 178
 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)))
 183 }
 184
 185 fn macro_expand(db: &dyn AstDatabase, id: MacroCallId) -> ExpandResult<Option<Arc<tt::Subtree>>> {
 186     macro_expand_with_arg(db, id, None)
 187 }
 188
 189 fn macro_expand_error(db: &dyn AstDatabase, macro_call: MacroCallId) -> Option<ExpandError> {
 190     db.macro_expand(macro_call).err
 191 }
 192
 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) => {
 197             return None;
 198         }
 199     };
 200
 201     let loc = db.lookup_intern_macro(lazy_id);
 202     let macro_rules = db.macro_def(loc.def)?;
 203     Some(macro_rules)
 204 }
 205
 206 fn macro_expand_with_arg(
 207     db: &dyn AstDatabase,
 208     id: MacroCallId,
 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) => {
 215             if arg.is_some() {
 216                 return ExpandResult::str_err(
 217                     "hypothetical macro expansion not implemented for eager macro".to_owned(),
 218                 );
 219             } else {
 220                 return ExpandResult {
 221                     value: Some(db.lookup_intern_eager_expansion(id).subtree),
 222                     // FIXME: There could be errors here!
 223                     err: None,
 224                 };
 225             }
 226         }
 227     };
 228
 229     let loc = db.lookup_intern_macro(lazy_id);
 230     let macro_arg = match arg.or_else(|| db.macro_arg(id)) {
 231         Some(it) => it,
 232         None => return ExpandResult::str_err("Fail to args in to tt::TokenTree".into()),
 233     };
 234
 235     let macro_rules = match db.macro_def(loc.def) {
 236         Some(it) => it,
 237         None => return ExpandResult::str_err("Fail to find macro definition".into()),
 238     };
 239     let ExpandResult { value: tt, err } = macro_rules.0.expand(db, lazy_id, &macro_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 {}",
 245             count, TOKEN_LIMIT,
 246         ));
 247     }
 248
 249     ExpandResult { value: Some(Arc::new(tt)), err }
 250 }
 251
 252 fn expand_proc_macro(
 253     db: &dyn AstDatabase,
 254     id: MacroCallId,
 255 ) -> Result<tt::Subtree, mbe::ExpandError> {
 256     let lazy_id = match id {
 257         MacroCallId::LazyMacro(id) => id,
 258         MacroCallId::EagerMacro(_) => unreachable!(),
 259     };
 260
 261     let loc = db.lookup_intern_macro(lazy_id);
 262     let macro_arg = match db.macro_arg(id) {
 263         Some(it) => it,
 264         None => {
 265             return Err(
 266                 tt::ExpansionError::Unknown("No arguments for proc-macro".to_string()).into()
 267             )
 268         }
 269     };
 270
 271     let expander = match loc.def.kind {
 272         MacroDefKind::ProcMacro(expander) => expander,
 273         _ => unreachable!(),
 274     };
 275
 276     expander.expand(db, loc.krate, &macro_arg.0)
 277 }
 278
 279 fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
 280     match file_id.0 {
 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())
 284         }
 285     }
 286 }
 287
 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)
 293 }
 294
 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))
 303     } else {
 304         db.macro_expand(macro_call_id)
 305     };
 306
 307     let _p = profile::span("parse_macro_expansion");
 308
 309     if let Some(err) = &result.err {
 310         // Note:
 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);
 317
 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)
 321                 })
 322                 .map(|n| format!("{:#}", n.value))
 323                 .collect::<Vec<_>>()
 324                 .join("\n");
 325
 326                 log::warn!(
 327                     "fail on macro_parse: (reason: {:?} macro_call: {:#}) parents: {}",
 328                     err,
 329                     node.value,
 330                     parents
 331                 );
 332             }
 333             _ => {
 334                 log::warn!("fail on macro_parse: (reason: {:?})", err);
 335             }
 336         }
 337     }
 338     let tt = match result.value {
 339         Some(tt) => tt,
 340         None => return ExpandResult { value: None, err: result.err },
 341     };
 342
 343     let fragment_kind = to_fragment_kind(db, macro_call_id);
 344
 345     let (parse, rev_token_map) = match mbe::token_tree_to_syntax_node(&tt, fragment_kind) {
 346         Ok(it) => it,
 347         Err(err) => {
 348             return ExpandResult::only_err(err);
 349         }
 350     };
 351
 352     match result.err {
 353         Some(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) {
 358                 Some(it) => it,
 359                 None => {
 360                     return ExpandResult::only_err(err);
 361                 }
 362             };
 363
 364             if !diff(&node, &call_node.value).is_empty() {
 365                 ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: Some(err) }
 366             } else {
 367                 return ExpandResult::only_err(err);
 368             }
 369         }
 370         None => ExpandResult { value: Some((parse, Arc::new(rev_token_map))), err: None },
 371     }
 372 }
 373
 374 fn hygiene_frame(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<HygieneFrame> {
 375     Arc::new(HygieneFrame::new(db, file_id))
 376 }
 377
 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;
 385         }
 386     };
 387     let syn = db.lookup_intern_macro(lazy_id).kind.node(db).value;
 388
 389     let parent = match syn.parent() {
 390         Some(it) => it,
 391         None => {
 392             // FIXME:
 393             // If it is root, which means the parent HirFile
 394             // MacroKindFile must be non-items
 395             // return expr now.
 396             return FragmentKind::Expr;
 397         }
 398     };
 399
 400     match parent.kind() {
 401         MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
 402         ITEM_LIST => FragmentKind::Items,
 403         LET_STMT => {
 404             // FIXME: Handle Pattern
 405             FragmentKind::Expr
 406         }
 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,
 434         _ => {
 435             // Unknown , Just guess it is `Items`
 436             FragmentKind::Items
 437         }
 438     }
 439 }