crates/hir_def/src/nameres/collector.rs

   1 //! The core of the module-level name resolution algorithm.
   2 //!
   3 //! `DefCollector::collect` contains the fixed-point iteration loop which
   4 //! resolves imports and expands macros.
   5
   6 use std::iter;
   7
   8 use base_db::{CrateId, Edition, FileId, ProcMacroId};
   9 use cfg::{CfgExpr, CfgOptions};
  10 use hir_expand::{
  11     ast_id_map::FileAstId,
  12     builtin_attr_macro::find_builtin_attr,
  13     builtin_derive_macro::find_builtin_derive,
  14     builtin_fn_macro::find_builtin_macro,
  15     name::{name, AsName, Name},
  16     proc_macro::ProcMacroExpander,
  17     ExpandTo, HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
  18 };
  19 use hir_expand::{InFile, MacroCallLoc};
  20 use itertools::Itertools;
  21 use la_arena::Idx;
  22 use limit::Limit;
  23 use rustc_hash::{FxHashMap, FxHashSet};
  24 use syntax::{ast, SmolStr};
  25
  26 use crate::{
  27     attr::{Attr, AttrId, AttrInput, Attrs},
  28     attr_macro_as_call_id, builtin_attr,
  29     db::DefDatabase,
  30     derive_macro_as_call_id,
  31     intern::Interned,
  32     item_scope::{ImportType, PerNsGlobImports},
  33     item_tree::{
  34         self, Fields, FileItemTreeId, ImportKind, ItemTree, ItemTreeId, MacroCall, MacroDef,
  35         MacroRules, Mod, ModItem, ModKind, TreeId,
  36     },
  37     macro_call_as_call_id,
  38     nameres::{
  39         diagnostics::DefDiagnostic,
  40         mod_resolution::ModDir,
  41         path_resolution::ReachedFixedPoint,
  42         proc_macro::{ProcMacroDef, ProcMacroKind},
  43         BuiltinShadowMode, DefMap, ModuleData, ModuleOrigin, ResolveMode,
  44     },
  45     path::{ImportAlias, ModPath, PathKind},
  46     per_ns::PerNs,
  47     visibility::{RawVisibility, Visibility},
  48     AdtId, AstId, AstIdWithPath, ConstLoc, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern,
  49     LocalModuleId, ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
  50     UnresolvedMacro,
  51 };
  52
  53 static GLOB_RECURSION_LIMIT: Limit = Limit::new(100);
  54 static EXPANSION_DEPTH_LIMIT: Limit = Limit::new(128);
  55 static FIXED_POINT_LIMIT: Limit = Limit::new(8192);
  56
  57 pub(super) fn collect_defs(
  58     db: &dyn DefDatabase,
  59     mut def_map: DefMap,
  60     block: Option<AstId<ast::BlockExpr>>,
  61 ) -> DefMap {
  62     let crate_graph = db.crate_graph();
  63
  64     let mut deps = FxHashMap::default();
  65     // populate external prelude and dependency list
  66     for dep in &crate_graph[def_map.krate].dependencies {
  67         tracing::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
  68         let dep_def_map = db.crate_def_map(dep.crate_id);
  69         let dep_root = dep_def_map.module_id(dep_def_map.root);
  70
  71         deps.insert(dep.as_name(), dep_root.into());
  72
  73         if dep.is_prelude() && block.is_none() {
  74             def_map.extern_prelude.insert(dep.as_name(), dep_root.into());
  75         }
  76     }
  77
  78     let cfg_options = &crate_graph[def_map.krate].cfg_options;
  79     let proc_macros = &crate_graph[def_map.krate].proc_macro;
  80     let proc_macros = proc_macros
  81         .iter()
  82         .enumerate()
  83         .map(|(idx, it)| {
  84             // FIXME: a hacky way to create a Name from string.
  85             let name = tt::Ident { text: it.name.clone(), id: tt::TokenId::unspecified() };
  86             (name.as_name(), ProcMacroExpander::new(def_map.krate, ProcMacroId(idx as u32)))
  87         })
  88         .collect();
  89
  90     let mut collector = DefCollector {
  91         db,
  92         def_map,
  93         deps,
  94         glob_imports: FxHashMap::default(),
  95         unresolved_imports: Vec::new(),
  96         resolved_imports: Vec::new(),
  97         unresolved_macros: Vec::new(),
  98         mod_dirs: FxHashMap::default(),
  99         cfg_options,
 100         proc_macros,
 101         exports_proc_macros: false,
 102         from_glob_import: Default::default(),
 103         skip_attrs: Default::default(),
 104         derive_helpers_in_scope: Default::default(),
 105         registered_attrs: Default::default(),
 106         registered_tools: Default::default(),
 107     };
 108     match block {
 109         Some(block) => collector.seed_with_inner(block),
 110         None => collector.seed_with_top_level(),
 111     }
 112     collector.collect();
 113     let mut def_map = collector.finish();
 114     def_map.shrink_to_fit();
 115     def_map
 116 }
 117
 118 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 119 enum PartialResolvedImport {
 120     /// None of any namespaces is resolved
 121     Unresolved,
 122     /// One of namespaces is resolved
 123     Indeterminate(PerNs),
 124     /// All namespaces are resolved, OR it comes from other crate
 125     Resolved(PerNs),
 126 }
 127
 128 impl PartialResolvedImport {
 129     fn namespaces(self) -> PerNs {
 130         match self {
 131             PartialResolvedImport::Unresolved => PerNs::none(),
 132             PartialResolvedImport::Indeterminate(ns) | PartialResolvedImport::Resolved(ns) => ns,
 133         }
 134     }
 135 }
 136
 137 #[derive(Clone, Debug, Eq, PartialEq)]
 138 enum ImportSource {
 139     Import { id: ItemTreeId<item_tree::Import>, use_tree: Idx<ast::UseTree> },
 140     ExternCrate(ItemTreeId<item_tree::ExternCrate>),
 141 }
 142
 143 #[derive(Clone, Debug, Eq, PartialEq)]
 144 struct Import {
 145     path: Interned<ModPath>,
 146     alias: Option<ImportAlias>,
 147     visibility: RawVisibility,
 148     kind: ImportKind,
 149     is_prelude: bool,
 150     is_extern_crate: bool,
 151     is_macro_use: bool,
 152     source: ImportSource,
 153 }
 154
 155 impl Import {
 156     fn from_use(
 157         db: &dyn DefDatabase,
 158         krate: CrateId,
 159         tree: &ItemTree,
 160         id: ItemTreeId<item_tree::Import>,
 161     ) -> Vec<Self> {
 162         let it = &tree[id.value];
 163         let attrs = &tree.attrs(db, krate, ModItem::from(id.value).into());
 164         let visibility = &tree[it.visibility];
 165         let is_prelude = attrs.by_key("prelude_import").exists();
 166
 167         let mut res = Vec::new();
 168         it.use_tree.expand(|idx, path, kind, alias| {
 169             res.push(Self {
 170                 path: Interned::new(path), // FIXME this makes little sense
 171                 alias,
 172                 visibility: visibility.clone(),
 173                 kind,
 174                 is_prelude,
 175                 is_extern_crate: false,
 176                 is_macro_use: false,
 177                 source: ImportSource::Import { id, use_tree: idx },
 178             });
 179         });
 180         res
 181     }
 182
 183     fn from_extern_crate(
 184         db: &dyn DefDatabase,
 185         krate: CrateId,
 186         tree: &ItemTree,
 187         id: ItemTreeId<item_tree::ExternCrate>,
 188     ) -> Self {
 189         let it = &tree[id.value];
 190         let attrs = &tree.attrs(db, krate, ModItem::from(id.value).into());
 191         let visibility = &tree[it.visibility];
 192         Self {
 193             path: Interned::new(ModPath::from_segments(
 194                 PathKind::Plain,
 195                 iter::once(it.name.clone()),
 196             )),
 197             alias: it.alias.clone(),
 198             visibility: visibility.clone(),
 199             kind: ImportKind::Plain,
 200             is_prelude: false,
 201             is_extern_crate: true,
 202             is_macro_use: attrs.by_key("macro_use").exists(),
 203             source: ImportSource::ExternCrate(id),
 204         }
 205     }
 206 }
 207
 208 #[derive(Clone, Debug, Eq, PartialEq)]
 209 struct ImportDirective {
 210     module_id: LocalModuleId,
 211     import: Import,
 212     status: PartialResolvedImport,
 213 }
 214
 215 #[derive(Clone, Debug, Eq, PartialEq)]
 216 struct MacroDirective {
 217     module_id: LocalModuleId,
 218     depth: usize,
 219     kind: MacroDirectiveKind,
 220 }
 221
 222 #[derive(Clone, Debug, Eq, PartialEq)]
 223 enum MacroDirectiveKind {
 224     FnLike { ast_id: AstIdWithPath<ast::MacroCall>, expand_to: ExpandTo },
 225     Derive { ast_id: AstIdWithPath<ast::Item>, derive_attr: AttrId },
 226     Attr { ast_id: AstIdWithPath<ast::Item>, attr: Attr, mod_item: ModItem },
 227 }
 228
 229 struct DefData<'a> {
 230     id: ModuleDefId,
 231     name: &'a Name,
 232     visibility: &'a RawVisibility,
 233     has_constructor: bool,
 234 }
 235
 236 /// Walks the tree of module recursively
 237 struct DefCollector<'a> {
 238     db: &'a dyn DefDatabase,
 239     def_map: DefMap,
 240     deps: FxHashMap<Name, ModuleDefId>,
 241     glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, Visibility)>>,
 242     unresolved_imports: Vec<ImportDirective>,
 243     resolved_imports: Vec<ImportDirective>,
 244     unresolved_macros: Vec<MacroDirective>,
 245     mod_dirs: FxHashMap<LocalModuleId, ModDir>,
 246     cfg_options: &'a CfgOptions,
 247     /// List of procedural macros defined by this crate. This is read from the dynamic library
 248     /// built by the build system, and is the list of proc. macros we can actually expand. It is
 249     /// empty when proc. macro support is disabled (in which case we still do name resolution for
 250     /// them).
 251     proc_macros: Vec<(Name, ProcMacroExpander)>,
 252     exports_proc_macros: bool,
 253     from_glob_import: PerNsGlobImports,
 254     /// If we fail to resolve an attribute on a `ModItem`, we fall back to ignoring the attribute.
 255     /// This map is used to skip all attributes up to and including the one that failed to resolve,
 256     /// in order to not expand them twice.
 257     ///
 258     /// This also stores the attributes to skip when we resolve derive helpers and non-macro
 259     /// non-builtin attributes in general.
 260     skip_attrs: FxHashMap<InFile<ModItem>, AttrId>,
 261     /// Tracks which custom derives are in scope for an item, to allow resolution of derive helper
 262     /// attributes.
 263     derive_helpers_in_scope: FxHashMap<AstId<ast::Item>, Vec<Name>>,
 264     /// Custom attributes registered with `#![register_attr]`.
 265     registered_attrs: Vec<SmolStr>,
 266     /// Custom tool modules registered with `#![register_tool]`.
 267     registered_tools: Vec<SmolStr>,
 268 }
 269
 270 impl DefCollector<'_> {
 271     fn seed_with_top_level(&mut self) {
 272         let _p = profile::span("seed_with_top_level");
 273
 274         let file_id = self.db.crate_graph()[self.def_map.krate].root_file_id;
 275         let item_tree = self.db.file_item_tree(file_id.into());
 276         let module_id = self.def_map.root;
 277
 278         let attrs = item_tree.top_level_attrs(self.db, self.def_map.krate);
 279         if attrs.cfg().map_or(true, |cfg| self.cfg_options.check(&cfg) != Some(false)) {
 280             self.inject_prelude(&attrs);
 281
 282             // Process other crate-level attributes.
 283             for attr in &*attrs {
 284                 let attr_name = match attr.path.as_ident() {
 285                     Some(name) => name,
 286                     None => continue,
 287                 };
 288
 289                 let attr_is_register_like = *attr_name == hir_expand::name![register_attr]
 290                     || *attr_name == hir_expand::name![register_tool];
 291                 if !attr_is_register_like {
 292                     continue;
 293                 }
 294
 295                 let registered_name = match attr.input.as_deref() {
 296                     Some(AttrInput::TokenTree(subtree, _)) => match &*subtree.token_trees {
 297                         [tt::TokenTree::Leaf(tt::Leaf::Ident(name))] => name.as_name(),
 298                         _ => continue,
 299                     },
 300                     _ => continue,
 301                 };
 302
 303                 if *attr_name == hir_expand::name![register_attr] {
 304                     self.registered_attrs.push(registered_name.to_smol_str());
 305                     cov_mark::hit!(register_attr);
 306                 } else {
 307                     self.registered_tools.push(registered_name.to_smol_str());
 308                     cov_mark::hit!(register_tool);
 309                 }
 310             }
 311
 312             ModCollector {
 313                 def_collector: self,
 314                 macro_depth: 0,
 315                 module_id,
 316                 tree_id: TreeId::new(file_id.into(), None),
 317                 item_tree: &item_tree,
 318                 mod_dir: ModDir::root(),
 319             }
 320             .collect(item_tree.top_level_items());
 321         }
 322     }
 323
 324     fn seed_with_inner(&mut self, block: AstId<ast::BlockExpr>) {
 325         let item_tree = self.db.file_item_tree(block.file_id);
 326         let module_id = self.def_map.root;
 327
 328         let is_cfg_enabled = item_tree
 329             .top_level_attrs(self.db, self.def_map.krate)
 330             .cfg()
 331             .map_or(true, |cfg| self.cfg_options.check(&cfg) != Some(false));
 332         if is_cfg_enabled {
 333             ModCollector {
 334                 def_collector: self,
 335                 macro_depth: 0,
 336                 module_id,
 337                 // FIXME: populate block once we have per-block ItemTrees
 338                 tree_id: TreeId::new(block.file_id, None),
 339                 item_tree: &item_tree,
 340                 mod_dir: ModDir::root(),
 341             }
 342             .collect(item_tree.inner_items_of_block(block.value));
 343         }
 344     }
 345
 346     fn resolution_loop(&mut self) {
 347         let _p = profile::span("DefCollector::resolution_loop");
 348
 349         // main name resolution fixed-point loop.
 350         let mut i = 0;
 351         'outer: loop {
 352             loop {
 353                 self.db.unwind_if_cancelled();
 354                 {
 355                     let _p = profile::span("resolve_imports loop");
 356                     loop {
 357                         if self.resolve_imports() == ReachedFixedPoint::Yes {
 358                             break;
 359                         }
 360                     }
 361                 }
 362                 if self.resolve_macros() == ReachedFixedPoint::Yes {
 363                     break;
 364                 }
 365
 366                 i += 1;
 367                 if FIXED_POINT_LIMIT.check(i).is_err() {
 368                     tracing::error!("name resolution is stuck");
 369                     break 'outer;
 370                 }
 371             }
 372
 373             if self.reseed_with_unresolved_attribute() == ReachedFixedPoint::Yes {
 374                 break;
 375             }
 376         }
 377     }
 378
 379     fn collect(&mut self) {
 380         let _p = profile::span("DefCollector::collect");
 381
 382         self.resolution_loop();
 383
 384         // Resolve all indeterminate resolved imports again
 385         // As some of the macros will expand newly import shadowing partial resolved imports
 386         // FIXME: We maybe could skip this, if we handle the indeterminate imports in `resolve_imports`
 387         // correctly
 388         let partial_resolved = self.resolved_imports.iter().filter_map(|directive| {
 389             if let PartialResolvedImport::Indeterminate(_) = directive.status {
 390                 let mut directive = directive.clone();
 391                 directive.status = PartialResolvedImport::Unresolved;
 392                 Some(directive)
 393             } else {
 394                 None
 395             }
 396         });
 397         self.unresolved_imports.extend(partial_resolved);
 398         self.resolve_imports();
 399
 400         let unresolved_imports = std::mem::take(&mut self.unresolved_imports);
 401         // show unresolved imports in completion, etc
 402         for directive in &unresolved_imports {
 403             self.record_resolved_import(directive)
 404         }
 405         self.unresolved_imports = unresolved_imports;
 406
 407         // FIXME: This condition should instead check if this is a `proc-macro` type crate.
 408         if self.exports_proc_macros {
 409             // A crate exporting procedural macros is not allowed to export anything else.
 410             //
 411             // Additionally, while the proc macro entry points must be `pub`, they are not publicly
 412             // exported in type/value namespace. This function reduces the visibility of all items
 413             // in the crate root that aren't proc macros.
 414             let root = self.def_map.root;
 415             let module_id = self.def_map.module_id(root);
 416             let root = &mut self.def_map.modules[root];
 417             root.scope.censor_non_proc_macros(module_id);
 418         }
 419     }
 420
 421     /// When the fixed-point loop reaches a stable state, we might still have some unresolved
 422     /// attributes (or unexpanded attribute proc macros) left over. This takes one of them, and
 423     /// feeds the item it's applied to back into name resolution.
 424     ///
 425     /// This effectively ignores the fact that the macro is there and just treats the items as
 426     /// normal code.
 427     ///
 428     /// This improves UX when proc macros are turned off or don't work, and replicates the behavior
 429     /// before we supported proc. attribute macros.
 430     fn reseed_with_unresolved_attribute(&mut self) -> ReachedFixedPoint {
 431         cov_mark::hit!(unresolved_attribute_fallback);
 432
 433         let mut unresolved_macros = std::mem::take(&mut self.unresolved_macros);
 434         let pos = unresolved_macros.iter().position(|directive| {
 435             if let MacroDirectiveKind::Attr { ast_id, mod_item, attr } = &directive.kind {
 436                 self.skip_attrs.insert(ast_id.ast_id.with_value(*mod_item), attr.id);
 437
 438                 let file_id = ast_id.ast_id.file_id;
 439                 let item_tree = self.db.file_item_tree(file_id);
 440                 let mod_dir = self.mod_dirs[&directive.module_id].clone();
 441                 ModCollector {
 442                     def_collector: self,
 443                     macro_depth: directive.depth,
 444                     module_id: directive.module_id,
 445                     tree_id: TreeId::new(file_id, None),
 446                     item_tree: &item_tree,
 447                     mod_dir,
 448                 }
 449                 .collect(&[*mod_item]);
 450                 true
 451             } else {
 452                 false
 453             }
 454         });
 455
 456         if let Some(pos) = pos {
 457             unresolved_macros.remove(pos);
 458         }
 459
 460         // The collection above might add new unresolved macros (eg. derives), so merge the lists.
 461         self.unresolved_macros.extend(unresolved_macros);
 462
 463         if pos.is_some() {
 464             // Continue name resolution with the new data.
 465             ReachedFixedPoint::No
 466         } else {
 467             ReachedFixedPoint::Yes
 468         }
 469     }
 470
 471     fn inject_prelude(&mut self, crate_attrs: &Attrs) {
 472         // See compiler/rustc_builtin_macros/src/standard_library_imports.rs
 473
 474         if crate_attrs.by_key("no_core").exists() {
 475             // libcore does not get a prelude.
 476             return;
 477         }
 478
 479         let krate = if crate_attrs.by_key("no_std").exists() {
 480             name![core]
 481         } else {
 482             let std = name![std];
 483             if self.def_map.extern_prelude().any(|(name, _)| *name == std) {
 484                 std
 485             } else {
 486                 // If `std` does not exist for some reason, fall back to core. This mostly helps
 487                 // keep r-a's own tests minimal.
 488                 name![core]
 489             }
 490         };
 491
 492         let edition = match self.def_map.edition {
 493             Edition::Edition2015 => name![rust_2015],
 494             Edition::Edition2018 => name![rust_2018],
 495             Edition::Edition2021 => name![rust_2021],
 496         };
 497
 498         let path_kind = if self.def_map.edition == Edition::Edition2015 {
 499             PathKind::Plain
 500         } else {
 501             PathKind::Abs
 502         };
 503         let path = ModPath::from_segments(
 504             path_kind.clone(),
 505             [krate.clone(), name![prelude], edition].into_iter(),
 506         );
 507         // Fall back to the older `std::prelude::v1` for compatibility with Rust <1.52.0
 508         // FIXME remove this fallback
 509         let fallback_path =
 510             ModPath::from_segments(path_kind, [krate, name![prelude], name![v1]].into_iter());
 511
 512         for path in &[path, fallback_path] {
 513             let (per_ns, _) = self.def_map.resolve_path(
 514                 self.db,
 515                 self.def_map.root,
 516                 path,
 517                 BuiltinShadowMode::Other,
 518             );
 519
 520             match per_ns.types {
 521                 Some((ModuleDefId::ModuleId(m), _)) => {
 522                     self.def_map.prelude = Some(m);
 523                     return;
 524                 }
 525                 types => {
 526                     tracing::debug!(
 527                         "could not resolve prelude path `{}` to module (resolved to {:?})",
 528                         path,
 529                         types
 530                     );
 531                 }
 532             }
 533         }
 534     }
 535
 536     /// Adds a definition of procedural macro `name` to the root module.
 537     ///
 538     /// # Notes on procedural macro resolution
 539     ///
 540     /// Procedural macro functionality is provided by the build system: It has to build the proc
 541     /// macro and pass the resulting dynamic library to rust-analyzer.
 542     ///
 543     /// When procedural macro support is enabled, the list of proc macros exported by a crate is
 544     /// known before we resolve names in the crate. This list is stored in `self.proc_macros` and is
 545     /// derived from the dynamic library.
 546     ///
 547     /// However, we *also* would like to be able to at least *resolve* macros on our own, without
 548     /// help by the build system. So, when the macro isn't found in `self.proc_macros`, we instead
 549     /// use a dummy expander that always errors. This comes with the drawback of macros potentially
 550     /// going out of sync with what the build system sees (since we resolve using VFS state, but
 551     /// Cargo builds only on-disk files). We could and probably should add diagnostics for that.
 552     fn export_proc_macro(&mut self, def: ProcMacroDef, ast_id: AstId<ast::Fn>) {
 553         let kind = def.kind.to_basedb_kind();
 554         self.exports_proc_macros = true;
 555         let macro_def = match self.proc_macros.iter().find(|(n, _)| n == &def.name) {
 556             Some(&(_, expander)) => MacroDefId {
 557                 krate: self.def_map.krate,
 558                 kind: MacroDefKind::ProcMacro(expander, kind, ast_id),
 559                 local_inner: false,
 560             },
 561             None => MacroDefId {
 562                 krate: self.def_map.krate,
 563                 kind: MacroDefKind::ProcMacro(
 564                     ProcMacroExpander::dummy(self.def_map.krate),
 565                     kind,
 566                     ast_id,
 567                 ),
 568                 local_inner: false,
 569             },
 570         };
 571
 572         self.define_proc_macro(def.name.clone(), macro_def);
 573         self.def_map.exported_proc_macros.insert(macro_def, def);
 574     }
 575
 576     /// Define a macro with `macro_rules`.
 577     ///
 578     /// It will define the macro in legacy textual scope, and if it has `#[macro_export]`,
 579     /// then it is also defined in the root module scope.
 580     /// You can `use` or invoke it by `crate::macro_name` anywhere, before or after the definition.
 581     ///
 582     /// It is surprising that the macro will never be in the current module scope.
 583     /// These code fails with "unresolved import/macro",
 584     /// ```rust,compile_fail
 585     /// mod m { macro_rules! foo { () => {} } }
 586     /// use m::foo as bar;
 587     /// ```
 588     ///
 589     /// ```rust,compile_fail
 590     /// macro_rules! foo { () => {} }
 591     /// self::foo!();
 592     /// crate::foo!();
 593     /// ```
 594     ///
 595     /// Well, this code compiles, because the plain path `foo` in `use` is searched
 596     /// in the legacy textual scope only.
 597     /// ```rust
 598     /// macro_rules! foo { () => {} }
 599     /// use foo as bar;
 600     /// ```
 601     fn define_macro_rules(
 602         &mut self,
 603         module_id: LocalModuleId,
 604         name: Name,
 605         macro_: MacroDefId,
 606         export: bool,
 607     ) {
 608         // Textual scoping
 609         self.define_legacy_macro(module_id, name.clone(), macro_);
 610
 611         // Module scoping
 612         // In Rust, `#[macro_export]` macros are unconditionally visible at the
 613         // crate root, even if the parent modules is **not** visible.
 614         if export {
 615             self.update(
 616                 self.def_map.root,
 617                 &[(Some(name), PerNs::macros(macro_, Visibility::Public))],
 618                 Visibility::Public,
 619                 ImportType::Named,
 620             );
 621         }
 622     }
 623
 624     /// Define a legacy textual scoped macro in module
 625     ///
 626     /// We use a map `legacy_macros` to store all legacy textual scoped macros visible per module.
 627     /// It will clone all macros from parent legacy scope, whose definition is prior to
 628     /// the definition of current module.
 629     /// And also, `macro_use` on a module will import all legacy macros visible inside to
 630     /// current legacy scope, with possible shadowing.
 631     fn define_legacy_macro(&mut self, module_id: LocalModuleId, name: Name, mac: MacroDefId) {
 632         // Always shadowing
 633         self.def_map.modules[module_id].scope.define_legacy_macro(name, mac);
 634     }
 635
 636     /// Define a macro 2.0 macro
 637     ///
 638     /// The scoped of macro 2.0 macro is equal to normal function
 639     fn define_macro_def(
 640         &mut self,
 641         module_id: LocalModuleId,
 642         name: Name,
 643         macro_: MacroDefId,
 644         vis: &RawVisibility,
 645     ) {
 646         let vis =
 647             self.def_map.resolve_visibility(self.db, module_id, vis).unwrap_or(Visibility::Public);
 648         self.update(module_id, &[(Some(name), PerNs::macros(macro_, vis))], vis, ImportType::Named);
 649     }
 650
 651     /// Define a proc macro
 652     ///
 653     /// A proc macro is similar to normal macro scope, but it would not visible in legacy textual scoped.
 654     /// And unconditionally exported.
 655     fn define_proc_macro(&mut self, name: Name, macro_: MacroDefId) {
 656         self.update(
 657             self.def_map.root,
 658             &[(Some(name), PerNs::macros(macro_, Visibility::Public))],
 659             Visibility::Public,
 660             ImportType::Named,
 661         );
 662     }
 663
 664     /// Import macros from `#[macro_use] extern crate`.
 665     fn import_macros_from_extern_crate(
 666         &mut self,
 667         current_module_id: LocalModuleId,
 668         extern_crate: &item_tree::ExternCrate,
 669     ) {
 670         tracing::debug!(
 671             "importing macros from extern crate: {:?} ({:?})",
 672             extern_crate,
 673             self.def_map.edition,
 674         );
 675
 676         let res = self.resolve_extern_crate(&extern_crate.name);
 677
 678         if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
 679             if m == self.def_map.module_id(current_module_id) {
 680                 cov_mark::hit!(ignore_macro_use_extern_crate_self);
 681                 return;
 682             }
 683
 684             cov_mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use);
 685             self.import_all_macros_exported(current_module_id, m.krate);
 686         }
 687     }
 688
 689     /// Import all exported macros from another crate
 690     ///
 691     /// Exported macros are just all macros in the root module scope.
 692     /// Note that it contains not only all `#[macro_export]` macros, but also all aliases
 693     /// created by `use` in the root module, ignoring the visibility of `use`.
 694     fn import_all_macros_exported(&mut self, current_module_id: LocalModuleId, krate: CrateId) {
 695         let def_map = self.db.crate_def_map(krate);
 696         for (name, def) in def_map[def_map.root].scope.macros() {
 697             // `macro_use` only bring things into legacy scope.
 698             self.define_legacy_macro(current_module_id, name.clone(), def);
 699         }
 700     }
 701
 702     /// Tries to resolve every currently unresolved import.
 703     fn resolve_imports(&mut self) -> ReachedFixedPoint {
 704         let mut res = ReachedFixedPoint::Yes;
 705         let imports = std::mem::take(&mut self.unresolved_imports);
 706         let imports = imports
 707             .into_iter()
 708             .filter_map(|mut directive| {
 709                 directive.status = self.resolve_import(directive.module_id, &directive.import);
 710                 match directive.status {
 711                     PartialResolvedImport::Indeterminate(_) => {
 712                         self.record_resolved_import(&directive);
 713                         // FIXME: For avoid performance regression,
 714                         // we consider an imported resolved if it is indeterminate (i.e not all namespace resolved)
 715                         self.resolved_imports.push(directive);
 716                         res = ReachedFixedPoint::No;
 717                         None
 718                     }
 719                     PartialResolvedImport::Resolved(_) => {
 720                         self.record_resolved_import(&directive);
 721                         self.resolved_imports.push(directive);
 722                         res = ReachedFixedPoint::No;
 723                         None
 724                     }
 725                     PartialResolvedImport::Unresolved => Some(directive),
 726                 }
 727             })
 728             .collect();
 729         self.unresolved_imports = imports;
 730         res
 731     }
 732
 733     fn resolve_import(&self, module_id: LocalModuleId, import: &Import) -> PartialResolvedImport {
 734         let _p = profile::span("resolve_import").detail(|| format!("{}", import.path));
 735         tracing::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
 736         if import.is_extern_crate {
 737             let name = import
 738                 .path
 739                 .as_ident()
 740                 .expect("extern crate should have been desugared to one-element path");
 741
 742             let res = self.resolve_extern_crate(name);
 743
 744             if res.is_none() {
 745                 PartialResolvedImport::Unresolved
 746             } else {
 747                 PartialResolvedImport::Resolved(res)
 748             }
 749         } else {
 750             let res = self.def_map.resolve_path_fp_with_macro(
 751                 self.db,
 752                 ResolveMode::Import,
 753                 module_id,
 754                 &import.path,
 755                 BuiltinShadowMode::Module,
 756             );
 757
 758             let def = res.resolved_def;
 759             if res.reached_fixedpoint == ReachedFixedPoint::No || def.is_none() {
 760                 return PartialResolvedImport::Unresolved;
 761             }
 762
 763             if let Some(krate) = res.krate {
 764                 if krate != self.def_map.krate {
 765                     return PartialResolvedImport::Resolved(
 766                         def.filter_visibility(|v| matches!(v, Visibility::Public)),
 767                     );
 768                 }
 769             }
 770
 771             // Check whether all namespace is resolved
 772             if def.take_types().is_some()
 773                 && def.take_values().is_some()
 774                 && def.take_macros().is_some()
 775             {
 776                 PartialResolvedImport::Resolved(def)
 777             } else {
 778                 PartialResolvedImport::Indeterminate(def)
 779             }
 780         }
 781     }
 782
 783     fn resolve_extern_crate(&self, name: &Name) -> PerNs {
 784         if *name == name!(self) {
 785             cov_mark::hit!(extern_crate_self_as);
 786             let root = match self.def_map.block {
 787                 Some(_) => {
 788                     let def_map = self.def_map.crate_root(self.db).def_map(self.db);
 789                     def_map.module_id(def_map.root())
 790                 }
 791                 None => self.def_map.module_id(self.def_map.root()),
 792             };
 793             PerNs::types(root.into(), Visibility::Public)
 794         } else {
 795             self.deps.get(name).map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public))
 796         }
 797     }
 798
 799     fn record_resolved_import(&mut self, directive: &ImportDirective) {
 800         let _p = profile::span("record_resolved_import");
 801
 802         let module_id = directive.module_id;
 803         let import = &directive.import;
 804         let mut def = directive.status.namespaces();
 805         let vis = self
 806             .def_map
 807             .resolve_visibility(self.db, module_id, &directive.import.visibility)
 808             .unwrap_or(Visibility::Public);
 809
 810         match import.kind {
 811             ImportKind::Plain | ImportKind::TypeOnly => {
 812                 let name = match &import.alias {
 813                     Some(ImportAlias::Alias(name)) => Some(name),
 814                     Some(ImportAlias::Underscore) => None,
 815                     None => match import.path.segments().last() {
 816                         Some(last_segment) => Some(last_segment),
 817                         None => {
 818                             cov_mark::hit!(bogus_paths);
 819                             return;
 820                         }
 821                     },
 822                 };
 823
 824                 if import.kind == ImportKind::TypeOnly {
 825                     def.values = None;
 826                     def.macros = None;
 827                 }
 828
 829                 tracing::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
 830
 831                 // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
 832                 if import.is_extern_crate && module_id == self.def_map.root {
 833                     if let (Some(def), Some(name)) = (def.take_types(), name) {
 834                         self.def_map.extern_prelude.insert(name.clone(), def);
 835                     }
 836                 }
 837
 838                 self.update(module_id, &[(name.cloned(), def)], vis, ImportType::Named);
 839             }
 840             ImportKind::Glob => {
 841                 tracing::debug!("glob import: {:?}", import);
 842                 match def.take_types() {
 843                     Some(ModuleDefId::ModuleId(m)) => {
 844                         if import.is_prelude {
 845                             // Note: This dodgily overrides the injected prelude. The rustc
 846                             // implementation seems to work the same though.
 847                             cov_mark::hit!(std_prelude);
 848                             self.def_map.prelude = Some(m);
 849                         } else if m.krate != self.def_map.krate {
 850                             cov_mark::hit!(glob_across_crates);
 851                             // glob import from other crate => we can just import everything once
 852                             let item_map = m.def_map(self.db);
 853                             let scope = &item_map[m.local_id].scope;
 854
 855                             // Module scoped macros is included
 856                             let items = scope
 857                                 .resolutions()
 858                                 // only keep visible names...
 859                                 .map(|(n, res)| {
 860                                     (n, res.filter_visibility(|v| v.is_visible_from_other_crate()))
 861                                 })
 862                                 .filter(|(_, res)| !res.is_none())
 863                                 .collect::<Vec<_>>();
 864
 865                             self.update(module_id, &items, vis, ImportType::Glob);
 866                         } else {
 867                             // glob import from same crate => we do an initial
 868                             // import, and then need to propagate any further
 869                             // additions
 870                             let def_map;
 871                             let scope = if m.block == self.def_map.block_id() {
 872                                 &self.def_map[m.local_id].scope
 873                             } else {
 874                                 def_map = m.def_map(self.db);
 875                                 &def_map[m.local_id].scope
 876                             };
 877
 878                             // Module scoped macros is included
 879                             let items = scope
 880                                 .resolutions()
 881                                 // only keep visible names...
 882                                 .map(|(n, res)| {
 883                                     (
 884                                         n,
 885                                         res.filter_visibility(|v| {
 886                                             v.is_visible_from_def_map(
 887                                                 self.db,
 888                                                 &self.def_map,
 889                                                 module_id,
 890                                             )
 891                                         }),
 892                                     )
 893                                 })
 894                                 .filter(|(_, res)| !res.is_none())
 895                                 .collect::<Vec<_>>();
 896
 897                             self.update(module_id, &items, vis, ImportType::Glob);
 898                             // record the glob import in case we add further items
 899                             let glob = self.glob_imports.entry(m.local_id).or_default();
 900                             if !glob.iter().any(|(mid, _)| *mid == module_id) {
 901                                 glob.push((module_id, vis));
 902                             }
 903                         }
 904                     }
 905                     Some(ModuleDefId::AdtId(AdtId::EnumId(e))) => {
 906                         cov_mark::hit!(glob_enum);
 907                         // glob import from enum => just import all the variants
 908
 909                         // XXX: urgh, so this works by accident! Here, we look at
 910                         // the enum data, and, in theory, this might require us to
 911                         // look back at the crate_def_map, creating a cycle. For
 912                         // example, `enum E { crate::some_macro!(); }`. Luckily, the
 913                         // only kind of macro that is allowed inside enum is a
 914                         // `cfg_macro`, and we don't need to run name resolution for
 915                         // it, but this is sheer luck!
 916                         let enum_data = self.db.enum_data(e);
 917                         let resolutions = enum_data
 918                             .variants
 919                             .iter()
 920                             .map(|(local_id, variant_data)| {
 921                                 let name = variant_data.name.clone();
 922                                 let variant = EnumVariantId { parent: e, local_id };
 923                                 let res = PerNs::both(variant.into(), variant.into(), vis);
 924                                 (Some(name), res)
 925                             })
 926                             .collect::<Vec<_>>();
 927                         self.update(module_id, &resolutions, vis, ImportType::Glob);
 928                     }
 929                     Some(d) => {
 930                         tracing::debug!("glob import {:?} from non-module/enum {:?}", import, d);
 931                     }
 932                     None => {
 933                         tracing::debug!("glob import {:?} didn't resolve as type", import);
 934                     }
 935                 }
 936             }
 937         }
 938     }
 939
 940     fn update(
 941         &mut self,
 942         module_id: LocalModuleId,
 943         resolutions: &[(Option<Name>, PerNs)],
 944         vis: Visibility,
 945         import_type: ImportType,
 946     ) {
 947         self.db.unwind_if_cancelled();
 948         self.update_recursive(module_id, resolutions, vis, import_type, 0)
 949     }
 950
 951     fn update_recursive(
 952         &mut self,
 953         module_id: LocalModuleId,
 954         resolutions: &[(Option<Name>, PerNs)],
 955         // All resolutions are imported with this visibility; the visibilities in
 956         // the `PerNs` values are ignored and overwritten
 957         vis: Visibility,
 958         import_type: ImportType,
 959         depth: usize,
 960     ) {
 961         if GLOB_RECURSION_LIMIT.check(depth).is_err() {
 962             // prevent stack overflows (but this shouldn't be possible)
 963             panic!("infinite recursion in glob imports!");
 964         }
 965         let mut changed = false;
 966
 967         for (name, res) in resolutions {
 968             match name {
 969                 Some(name) => {
 970                     let scope = &mut self.def_map.modules[module_id].scope;
 971                     changed |= scope.push_res_with_import(
 972                         &mut self.from_glob_import,
 973                         (module_id, name.clone()),
 974                         res.with_visibility(vis),
 975                         import_type,
 976                     );
 977                 }
 978                 None => {
 979                     let tr = match res.take_types() {
 980                         Some(ModuleDefId::TraitId(tr)) => tr,
 981                         Some(other) => {
 982                             tracing::debug!("non-trait `_` import of {:?}", other);
 983                             continue;
 984                         }
 985                         None => continue,
 986                     };
 987                     let old_vis = self.def_map.modules[module_id].scope.unnamed_trait_vis(tr);
 988                     let should_update = match old_vis {
 989                         None => true,
 990                         Some(old_vis) => {
 991                             let max_vis = old_vis.max(vis, &self.def_map).unwrap_or_else(|| {
 992                                 panic!("`Tr as _` imports with unrelated visibilities {:?} and {:?} (trait {:?})", old_vis, vis, tr);
 993                             });
 994
 995                             if max_vis == old_vis {
 996                                 false
 997                             } else {
 998                                 cov_mark::hit!(upgrade_underscore_visibility);
 999                                 true
1000                             }
1001                         }
1002                     };
1003
1004                     if should_update {
1005                         changed = true;
1006                         self.def_map.modules[module_id].scope.push_unnamed_trait(tr, vis);
1007                     }
1008                 }
1009             }
1010         }
1011
1012         if !changed {
1013             return;
1014         }
1015         let glob_imports = self
1016             .glob_imports
1017             .get(&module_id)
1018             .into_iter()
1019             .flat_map(|v| v.iter())
1020             .filter(|(glob_importing_module, _)| {
1021                 // we know all resolutions have the same visibility (`vis`), so we
1022                 // just need to check that once
1023                 vis.is_visible_from_def_map(self.db, &self.def_map, *glob_importing_module)
1024             })
1025             .cloned()
1026             .collect::<Vec<_>>();
1027
1028         for (glob_importing_module, glob_import_vis) in glob_imports {
1029             self.update_recursive(
1030                 glob_importing_module,
1031                 resolutions,
1032                 glob_import_vis,
1033                 ImportType::Glob,
1034                 depth + 1,
1035             );
1036         }
1037     }
1038
1039     fn resolve_macros(&mut self) -> ReachedFixedPoint {
1040         let mut macros = std::mem::take(&mut self.unresolved_macros);
1041         let mut resolved = Vec::new();
1042         let mut res = ReachedFixedPoint::Yes;
1043         macros.retain(|directive| {
1044             let resolver = |path| {
1045                 let resolved_res = self.def_map.resolve_path_fp_with_macro(
1046                     self.db,
1047                     ResolveMode::Other,
1048                     directive.module_id,
1049                     &path,
1050                     BuiltinShadowMode::Module,
1051                 );
1052                 resolved_res.resolved_def.take_macros()
1053             };
1054
1055             match &directive.kind {
1056                 MacroDirectiveKind::FnLike { ast_id, expand_to } => {
1057                     let call_id = macro_call_as_call_id(
1058                         ast_id,
1059                         *expand_to,
1060                         self.db,
1061                         self.def_map.krate,
1062                         &resolver,
1063                         &mut |_err| (),
1064                     );
1065                     match call_id {
1066                         Ok(Ok(call_id)) => {
1067                             resolved.push((directive.module_id, call_id, directive.depth));
1068                             res = ReachedFixedPoint::No;
1069                             return false;
1070                         }
1071                         Err(UnresolvedMacro { .. }) | Ok(Err(_)) => {}
1072                     }
1073                 }
1074                 MacroDirectiveKind::Derive { ast_id, derive_attr } => {
1075                     let call_id = derive_macro_as_call_id(
1076                         ast_id,
1077                         *derive_attr,
1078                         self.db,
1079                         self.def_map.krate,
1080                         &resolver,
1081                     );
1082                     match call_id {
1083                         Ok(call_id) => {
1084                             self.def_map.modules[directive.module_id].scope.add_derive_macro_invoc(
1085                                 ast_id.ast_id,
1086                                 call_id,
1087                                 *derive_attr,
1088                             );
1089
1090                             resolved.push((directive.module_id, call_id, directive.depth));
1091                             res = ReachedFixedPoint::No;
1092                             return false;
1093                         }
1094                         Err(UnresolvedMacro { .. }) => {}
1095                     }
1096                 }
1097                 MacroDirectiveKind::Attr { ast_id, mod_item, attr } => {
1098                     let file_id = ast_id.ast_id.file_id;
1099                     let mut recollect_without = |collector: &mut Self, item_tree| {
1100                         // Remove the original directive since we resolved it.
1101                         let mod_dir = collector.mod_dirs[&directive.module_id].clone();
1102                         collector.skip_attrs.insert(InFile::new(file_id, *mod_item), attr.id);
1103                         ModCollector {
1104                             def_collector: collector,
1105                             macro_depth: directive.depth,
1106                             module_id: directive.module_id,
1107                             tree_id: TreeId::new(file_id, None),
1108                             item_tree,
1109                             mod_dir,
1110                         }
1111                         .collect(&[*mod_item]);
1112                         res = ReachedFixedPoint::No;
1113                         false
1114                     };
1115
1116                     if let Some(ident) = ast_id.path.as_ident() {
1117                         if let Some(helpers) = self.derive_helpers_in_scope.get(&ast_id.ast_id) {
1118                             if helpers.contains(ident) {
1119                                 cov_mark::hit!(resolved_derive_helper);
1120                                 // Resolved to derive helper. Collect the item's attributes again,
1121                                 // starting after the derive helper.
1122                                 let item_tree = self.db.file_item_tree(file_id);
1123                                 return recollect_without(self, &item_tree);
1124                             }
1125                         }
1126                     }
1127
1128                     let def = resolver(ast_id.path.clone()).filter(MacroDefId::is_attribute);
1129                     if matches!(
1130                         def,
1131                         Some(MacroDefId {  kind:MacroDefKind::BuiltInAttr(expander, _),.. })
1132                         if expander.is_derive()
1133                     ) {
1134                         // Resolved to `#[derive]`
1135                         let file_id = ast_id.ast_id.file_id;
1136                         let item_tree = self.db.file_item_tree(file_id);
1137
1138                         let ast_id: FileAstId<ast::Item> = match *mod_item {
1139                             ModItem::Struct(it) => item_tree[it].ast_id.upcast(),
1140                             ModItem::Union(it) => item_tree[it].ast_id.upcast(),
1141                             ModItem::Enum(it) => item_tree[it].ast_id.upcast(),
1142                             _ => {
1143                                 // Cannot use derive on this item.
1144                                 // FIXME: diagnose
1145                                 res = ReachedFixedPoint::No;
1146                                 return false;
1147                             }
1148                         };
1149
1150                         match attr.parse_derive() {
1151                             Some(derive_macros) => {
1152                                 for path in derive_macros {
1153                                     let ast_id = AstIdWithPath::new(file_id, ast_id, path);
1154                                     self.unresolved_macros.push(MacroDirective {
1155                                         module_id: directive.module_id,
1156                                         depth: directive.depth + 1,
1157                                         kind: MacroDirectiveKind::Derive {
1158                                             ast_id,
1159                                             derive_attr: attr.id,
1160                                         },
1161                                     });
1162                                 }
1163                             }
1164                             None => {
1165                                 // FIXME: diagnose
1166                                 tracing::debug!("malformed derive: {:?}", attr);
1167                             }
1168                         }
1169
1170                         return recollect_without(self, &item_tree);
1171                     }
1172
1173                     if !self.db.enable_proc_attr_macros() {
1174                         return true;
1175                     }
1176
1177                     // Not resolved to a derive helper or the derive attribute, so try to resolve as a normal attribute.
1178                     match attr_macro_as_call_id(ast_id, attr, self.db, self.def_map.krate, def) {
1179                         Ok(call_id) => {
1180                             let loc: MacroCallLoc = self.db.lookup_intern_macro_call(call_id);
1181
1182                             // Skip #[test]/#[bench] expansion, which would merely result in more memory usage
1183                             // due to duplicating functions into macro expansions
1184                             if matches!(
1185                                 loc.def.kind,
1186                                 MacroDefKind::BuiltInAttr(expander, _)
1187                                 if expander.is_test() || expander.is_bench()
1188                             ) {
1189                                 let item_tree = self.db.file_item_tree(file_id);
1190                                 return recollect_without(self, &item_tree);
1191                             }
1192
1193                             if let MacroDefKind::ProcMacro(exp, ..) = loc.def.kind {
1194                                 if exp.is_dummy() {
1195                                     // Proc macros that cannot be expanded are treated as not
1196                                     // resolved, in order to fall back later.
1197                                     self.def_map.diagnostics.push(
1198                                         DefDiagnostic::unresolved_proc_macro(
1199                                             directive.module_id,
1200                                             loc.kind,
1201                                         ),
1202                                     );
1203
1204                                     let file_id = ast_id.ast_id.file_id;
1205                                     let item_tree = self.db.file_item_tree(file_id);
1206                                     return recollect_without(self, &item_tree);
1207                                 }
1208                             }
1209
1210                             self.def_map.modules[directive.module_id]
1211                                 .scope
1212                                 .add_attr_macro_invoc(ast_id.ast_id, call_id);
1213
1214                             resolved.push((directive.module_id, call_id, directive.depth));
1215                             res = ReachedFixedPoint::No;
1216                             return false;
1217                         }
1218                         Err(UnresolvedMacro { .. }) => (),
1219                     }
1220                 }
1221             }
1222
1223             true
1224         });
1225         // Attribute resolution can add unresolved macro invocations, so concatenate the lists.
1226         self.unresolved_macros.extend(macros);
1227
1228         for (module_id, macro_call_id, depth) in resolved {
1229             self.collect_macro_expansion(module_id, macro_call_id, depth);
1230         }
1231
1232         res
1233     }
1234
1235     fn collect_macro_expansion(
1236         &mut self,
1237         module_id: LocalModuleId,
1238         macro_call_id: MacroCallId,
1239         depth: usize,
1240     ) {
1241         if EXPANSION_DEPTH_LIMIT.check(depth).is_err() {
1242             cov_mark::hit!(macro_expansion_overflow);
1243             tracing::warn!("macro expansion is too deep");
1244             return;
1245         }
1246         let file_id = macro_call_id.as_file();
1247
1248         // First, fetch the raw expansion result for purposes of error reporting. This goes through
1249         // `macro_expand_error` to avoid depending on the full expansion result (to improve
1250         // incrementality).
1251         let loc: MacroCallLoc = self.db.lookup_intern_macro_call(macro_call_id);
1252         let err = self.db.macro_expand_error(macro_call_id);
1253         if let Some(err) = err {
1254             let diag = match err {
1255                 hir_expand::ExpandError::UnresolvedProcMacro => {
1256                     // Missing proc macros are non-fatal, so they are handled specially.
1257                     DefDiagnostic::unresolved_proc_macro(module_id, loc.kind.clone())
1258                 }
1259                 _ => DefDiagnostic::macro_error(module_id, loc.kind.clone(), err.to_string()),
1260             };
1261
1262             self.def_map.diagnostics.push(diag);
1263         }
1264
1265         // If we've just resolved a derive, record its helper attributes.
1266         if let MacroCallKind::Derive { ast_id, .. } = &loc.kind {
1267             if loc.def.krate != self.def_map.krate {
1268                 let def_map = self.db.crate_def_map(loc.def.krate);
1269                 if let Some(def) = def_map.exported_proc_macros.get(&loc.def) {
1270                     if let ProcMacroKind::CustomDerive { helpers } = &def.kind {
1271                         self.derive_helpers_in_scope
1272                             .entry(*ast_id)
1273                             .or_default()
1274                             .extend(helpers.iter().cloned());
1275                     }
1276                 }
1277             }
1278         }
1279
1280         // Then, fetch and process the item tree. This will reuse the expansion result from above.
1281         let item_tree = self.db.file_item_tree(file_id);
1282         let mod_dir = self.mod_dirs[&module_id].clone();
1283         ModCollector {
1284             def_collector: &mut *self,
1285             macro_depth: depth,
1286             tree_id: TreeId::new(file_id, None),
1287             module_id,
1288             item_tree: &item_tree,
1289             mod_dir,
1290         }
1291         .collect(item_tree.top_level_items());
1292     }
1293
1294     fn finish(mut self) -> DefMap {
1295         // Emit diagnostics for all remaining unexpanded macros.
1296
1297         let _p = profile::span("DefCollector::finish");
1298
1299         for directive in &self.unresolved_macros {
1300             match &directive.kind {
1301                 MacroDirectiveKind::FnLike { ast_id, expand_to } => {
1302                     let macro_call_as_call_id = macro_call_as_call_id(
1303                         ast_id,
1304                         *expand_to,
1305                         self.db,
1306                         self.def_map.krate,
1307                         |path| {
1308                             let resolved_res = self.def_map.resolve_path_fp_with_macro(
1309                                 self.db,
1310                                 ResolveMode::Other,
1311                                 directive.module_id,
1312                                 &path,
1313                                 BuiltinShadowMode::Module,
1314                             );
1315                             resolved_res.resolved_def.take_macros()
1316                         },
1317                         &mut |_| (),
1318                     );
1319                     if let Err(UnresolvedMacro { path }) = macro_call_as_call_id {
1320                         self.def_map.diagnostics.push(DefDiagnostic::unresolved_macro_call(
1321                             directive.module_id,
1322                             ast_id.ast_id,
1323                             path,
1324                         ));
1325                     }
1326                 }
1327                 MacroDirectiveKind::Derive { .. } | MacroDirectiveKind::Attr { .. } => {
1328                     // FIXME: we might want to diagnose this too
1329                 }
1330             }
1331         }
1332
1333         // Emit diagnostics for all remaining unresolved imports.
1334
1335         // We'd like to avoid emitting a diagnostics avalanche when some `extern crate` doesn't
1336         // resolve. We first emit diagnostics for unresolved extern crates and collect the missing
1337         // crate names. Then we emit diagnostics for unresolved imports, but only if the import
1338         // doesn't start with an unresolved crate's name. Due to renaming and reexports, this is a
1339         // heuristic, but it works in practice.
1340         let mut diagnosed_extern_crates = FxHashSet::default();
1341         for directive in &self.unresolved_imports {
1342             if let ImportSource::ExternCrate(krate) = directive.import.source {
1343                 let item_tree = krate.item_tree(self.db);
1344                 let extern_crate = &item_tree[krate.value];
1345
1346                 diagnosed_extern_crates.insert(extern_crate.name.clone());
1347
1348                 self.def_map.diagnostics.push(DefDiagnostic::unresolved_extern_crate(
1349                     directive.module_id,
1350                     InFile::new(krate.file_id(), extern_crate.ast_id),
1351                 ));
1352             }
1353         }
1354
1355         for directive in &self.unresolved_imports {
1356             if let ImportSource::Import { id: import, use_tree } = &directive.import.source {
1357                 if let (Some(krate), PathKind::Plain | PathKind::Abs) =
1358                     (directive.import.path.segments().first(), &directive.import.path.kind)
1359                 {
1360                     if diagnosed_extern_crates.contains(krate) {
1361                         continue;
1362                     }
1363                 }
1364
1365                 self.def_map.diagnostics.push(DefDiagnostic::unresolved_import(
1366                     directive.module_id,
1367                     *import,
1368                     *use_tree,
1369                 ));
1370             }
1371         }
1372
1373         self.def_map
1374     }
1375 }
1376
1377 /// Walks a single module, populating defs, imports and macros
1378 struct ModCollector<'a, 'b> {
1379     def_collector: &'a mut DefCollector<'b>,
1380     macro_depth: usize,
1381     module_id: LocalModuleId,
1382     tree_id: TreeId,
1383     item_tree: &'a ItemTree,
1384     mod_dir: ModDir,
1385 }
1386
1387 impl ModCollector<'_, '_> {
1388     fn collect(&mut self, items: &[ModItem]) {
1389         let krate = self.def_collector.def_map.krate;
1390
1391         // Note: don't assert that inserted value is fresh: it's simply not true
1392         // for macros.
1393         self.def_collector.mod_dirs.insert(self.module_id, self.mod_dir.clone());
1394
1395         // Prelude module is always considered to be `#[macro_use]`.
1396         if let Some(prelude_module) = self.def_collector.def_map.prelude {
1397             if prelude_module.krate != krate {
1398                 cov_mark::hit!(prelude_is_macro_use);
1399                 self.def_collector.import_all_macros_exported(self.module_id, prelude_module.krate);
1400             }
1401         }
1402
1403         // This should be processed eagerly instead of deferred to resolving.
1404         // `#[macro_use] extern crate` is hoisted to imports macros before collecting
1405         // any other items.
1406         for item in items {
1407             let attrs = self.item_tree.attrs(self.def_collector.db, krate, (*item).into());
1408             if attrs.cfg().map_or(true, |cfg| self.is_cfg_enabled(&cfg)) {
1409                 if let ModItem::ExternCrate(id) = item {
1410                     let import = self.item_tree[*id].clone();
1411                     let attrs = self.item_tree.attrs(
1412                         self.def_collector.db,
1413                         krate,
1414                         ModItem::from(*id).into(),
1415                     );
1416                     if attrs.by_key("macro_use").exists() {
1417                         self.def_collector.import_macros_from_extern_crate(self.module_id, &import);
1418                     }
1419                 }
1420             }
1421         }
1422
1423         for &item in items {
1424             let attrs = self.item_tree.attrs(self.def_collector.db, krate, item.into());
1425             if let Some(cfg) = attrs.cfg() {
1426                 if !self.is_cfg_enabled(&cfg) {
1427                     self.emit_unconfigured_diagnostic(item, &cfg);
1428                     continue;
1429                 }
1430             }
1431
1432             if let Err(()) = self.resolve_attributes(&attrs, item) {
1433                 // Do not process the item. It has at least one non-builtin attribute, so the
1434                 // fixed-point algorithm is required to resolve the rest of them.
1435                 continue;
1436             }
1437
1438             let module = self.def_collector.def_map.module_id(self.module_id);
1439
1440             let mut def = None;
1441             match item {
1442                 ModItem::Mod(m) => self.collect_module(&self.item_tree[m], &attrs),
1443                 ModItem::Import(import_id) => {
1444                     let module_id = self.module_id;
1445                     let imports = Import::from_use(
1446                         self.def_collector.db,
1447                         krate,
1448                         self.item_tree,
1449                         ItemTreeId::new(self.tree_id, import_id),
1450                     );
1451                     self.def_collector.unresolved_imports.extend(imports.into_iter().map(
1452                         |import| ImportDirective {
1453                             module_id,
1454                             import,
1455                             status: PartialResolvedImport::Unresolved,
1456                         },
1457                     ));
1458                 }
1459                 ModItem::ExternCrate(import_id) => {
1460                     self.def_collector.unresolved_imports.push(ImportDirective {
1461                         module_id: self.module_id,
1462                         import: Import::from_extern_crate(
1463                             self.def_collector.db,
1464                             krate,
1465                             self.item_tree,
1466                             ItemTreeId::new(self.tree_id, import_id),
1467                         ),
1468                         status: PartialResolvedImport::Unresolved,
1469                     })
1470                 }
1471                 ModItem::ExternBlock(block) => self.collect(&self.item_tree[block].children),
1472                 ModItem::MacroCall(mac) => self.collect_macro_call(&self.item_tree[mac]),
1473                 ModItem::MacroRules(id) => self.collect_macro_rules(id),
1474                 ModItem::MacroDef(id) => self.collect_macro_def(id),
1475                 ModItem::Impl(imp) => {
1476                     let module = self.def_collector.def_map.module_id(self.module_id);
1477                     let impl_id =
1478                         ImplLoc { container: module, id: ItemTreeId::new(self.tree_id, imp) }
1479                             .intern(self.def_collector.db);
1480                     self.def_collector.def_map.modules[self.module_id].scope.define_impl(impl_id)
1481                 }
1482                 ModItem::Function(id) => {
1483                     let func = &self.item_tree[id];
1484
1485                     let ast_id = InFile::new(self.file_id(), func.ast_id);
1486                     self.collect_proc_macro_def(&func.name, ast_id, &attrs);
1487
1488                     def = Some(DefData {
1489                         id: FunctionLoc {
1490                             container: module.into(),
1491                             id: ItemTreeId::new(self.tree_id, id),
1492                         }
1493                         .intern(self.def_collector.db)
1494                         .into(),
1495                         name: &func.name,
1496                         visibility: &self.item_tree[func.visibility],
1497                         has_constructor: false,
1498                     });
1499                 }
1500                 ModItem::Struct(id) => {
1501                     let it = &self.item_tree[id];
1502
1503                     def = Some(DefData {
1504                         id: StructLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }
1505                             .intern(self.def_collector.db)
1506                             .into(),
1507                         name: &it.name,
1508                         visibility: &self.item_tree[it.visibility],
1509                         has_constructor: !matches!(it.fields, Fields::Record(_)),
1510                     });
1511                 }
1512                 ModItem::Union(id) => {
1513                     let it = &self.item_tree[id];
1514
1515                     def = Some(DefData {
1516                         id: UnionLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }
1517                             .intern(self.def_collector.db)
1518                             .into(),
1519                         name: &it.name,
1520                         visibility: &self.item_tree[it.visibility],
1521                         has_constructor: false,
1522                     });
1523                 }
1524                 ModItem::Enum(id) => {
1525                     let it = &self.item_tree[id];
1526
1527                     def = Some(DefData {
1528                         id: EnumLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }
1529                             .intern(self.def_collector.db)
1530                             .into(),
1531                         name: &it.name,
1532                         visibility: &self.item_tree[it.visibility],
1533                         has_constructor: false,
1534                     });
1535                 }
1536                 ModItem::Const(id) => {
1537                     let it = &self.item_tree[id];
1538                     let const_id = ConstLoc {
1539                         container: module.into(),
1540                         id: ItemTreeId::new(self.tree_id, id),
1541                     }
1542                     .intern(self.def_collector.db);
1543
1544                     match &it.name {
1545                         Some(name) => {
1546                             def = Some(DefData {
1547                                 id: const_id.into(),
1548                                 name,
1549                                 visibility: &self.item_tree[it.visibility],
1550                                 has_constructor: false,
1551                             });
1552                         }
1553                         None => {
1554                             // const _: T = ...;
1555                             self.def_collector.def_map.modules[self.module_id]
1556                                 .scope
1557                                 .define_unnamed_const(const_id);
1558                         }
1559                     }
1560                 }
1561                 ModItem::Static(id) => {
1562                     let it = &self.item_tree[id];
1563
1564                     def = Some(DefData {
1565                         id: StaticLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }
1566                             .intern(self.def_collector.db)
1567                             .into(),
1568                         name: &it.name,
1569                         visibility: &self.item_tree[it.visibility],
1570                         has_constructor: false,
1571                     });
1572                 }
1573                 ModItem::Trait(id) => {
1574                     let it = &self.item_tree[id];
1575
1576                     def = Some(DefData {
1577                         id: TraitLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }
1578                             .intern(self.def_collector.db)
1579                             .into(),
1580                         name: &it.name,
1581                         visibility: &self.item_tree[it.visibility],
1582                         has_constructor: false,
1583                     });
1584                 }
1585                 ModItem::TypeAlias(id) => {
1586                     let it = &self.item_tree[id];
1587
1588                     def = Some(DefData {
1589                         id: TypeAliasLoc {
1590                             container: module.into(),
1591                             id: ItemTreeId::new(self.tree_id, id),
1592                         }
1593                         .intern(self.def_collector.db)
1594                         .into(),
1595                         name: &it.name,
1596                         visibility: &self.item_tree[it.visibility],
1597                         has_constructor: false,
1598                     });
1599                 }
1600             }
1601
1602             if let Some(DefData { id, name, visibility, has_constructor }) = def {
1603                 self.def_collector.def_map.modules[self.module_id].scope.declare(id);
1604                 let vis = self
1605                     .def_collector
1606                     .def_map
1607                     .resolve_visibility(self.def_collector.db, self.module_id, visibility)
1608                     .unwrap_or(Visibility::Public);
1609                 self.def_collector.update(
1610                     self.module_id,
1611                     &[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
1612                     vis,
1613                     ImportType::Named,
1614                 )
1615             }
1616         }
1617     }
1618
1619     fn collect_module(&mut self, module: &Mod, attrs: &Attrs) {
1620         let path_attr = attrs.by_key("path").string_value();
1621         let is_macro_use = attrs.by_key("macro_use").exists();
1622         match &module.kind {
1623             // inline module, just recurse
1624             ModKind::Inline { items } => {
1625                 let module_id = self.push_child_module(
1626                     module.name.clone(),
1627                     AstId::new(self.file_id(), module.ast_id),
1628                     None,
1629                     &self.item_tree[module.visibility],
1630                 );
1631
1632                 if let Some(mod_dir) = self.mod_dir.descend_into_definition(&module.name, path_attr)
1633                 {
1634                     ModCollector {
1635                         def_collector: &mut *self.def_collector,
1636                         macro_depth: self.macro_depth,
1637                         module_id,
1638                         tree_id: self.tree_id,
1639                         item_tree: self.item_tree,
1640                         mod_dir,
1641                     }
1642                     .collect(&*items);
1643                     if is_macro_use {
1644                         self.import_all_legacy_macros(module_id);
1645                     }
1646                 }
1647             }
1648             // out of line module, resolve, parse and recurse
1649             ModKind::Outline {} => {
1650                 let ast_id = AstId::new(self.tree_id.file_id(), module.ast_id);
1651                 let db = self.def_collector.db;
1652                 match self.mod_dir.resolve_declaration(db, self.file_id(), &module.name, path_attr)
1653                 {
1654                     Ok((file_id, is_mod_rs, mod_dir)) => {
1655                         let item_tree = db.file_item_tree(file_id.into());
1656                         let is_enabled = item_tree
1657                             .top_level_attrs(db, self.def_collector.def_map.krate)
1658                             .cfg()
1659                             .map_or(true, |cfg| {
1660                                 self.def_collector.cfg_options.check(&cfg) != Some(false)
1661                             });
1662                         if is_enabled {
1663                             let module_id = self.push_child_module(
1664                                 module.name.clone(),
1665                                 ast_id,
1666                                 Some((file_id, is_mod_rs)),
1667                                 &self.item_tree[module.visibility],
1668                             );
1669                             ModCollector {
1670                                 def_collector: &mut *self.def_collector,
1671                                 macro_depth: self.macro_depth,
1672                                 module_id,
1673                                 tree_id: TreeId::new(file_id.into(), None),
1674                                 item_tree: &item_tree,
1675                                 mod_dir,
1676                             }
1677                             .collect(item_tree.top_level_items());
1678                             if is_macro_use
1679                                 || item_tree
1680                                     .top_level_attrs(db, self.def_collector.def_map.krate)
1681                                     .by_key("macro_use")
1682                                     .exists()
1683                             {
1684                                 self.import_all_legacy_macros(module_id);
1685                             }
1686                         }
1687                     }
1688                     Err(candidate) => {
1689                         self.def_collector.def_map.diagnostics.push(
1690                             DefDiagnostic::unresolved_module(self.module_id, ast_id, candidate),
1691                         );
1692                     }
1693                 };
1694             }
1695         }
1696     }
1697
1698     fn push_child_module(
1699         &mut self,
1700         name: Name,
1701         declaration: AstId<ast::Module>,
1702         definition: Option<(FileId, bool)>,
1703         visibility: &crate::visibility::RawVisibility,
1704     ) -> LocalModuleId {
1705         let vis = self
1706             .def_collector
1707             .def_map
1708             .resolve_visibility(self.def_collector.db, self.module_id, visibility)
1709             .unwrap_or(Visibility::Public);
1710         let modules = &mut self.def_collector.def_map.modules;
1711         let origin = match definition {
1712             None => ModuleOrigin::Inline { definition: declaration },
1713             Some((definition, is_mod_rs)) => {
1714                 ModuleOrigin::File { declaration, definition, is_mod_rs }
1715             }
1716         };
1717         let res = modules.alloc(ModuleData::new(origin, vis));
1718         modules[res].parent = Some(self.module_id);
1719         for (name, mac) in modules[self.module_id].scope.collect_legacy_macros() {
1720             modules[res].scope.define_legacy_macro(name, mac)
1721         }
1722         modules[self.module_id].children.insert(name.clone(), res);
1723         let module = self.def_collector.def_map.module_id(res);
1724         let def: ModuleDefId = module.into();
1725         self.def_collector.def_map.modules[self.module_id].scope.declare(def);
1726         self.def_collector.update(
1727             self.module_id,
1728             &[(Some(name), PerNs::from_def(def, vis, false))],
1729             vis,
1730             ImportType::Named,
1731         );
1732         res
1733     }
1734
1735     /// Resolves attributes on an item.
1736     ///
1737     /// Returns `Err` when some attributes could not be resolved to builtins and have been
1738     /// registered as unresolved.
1739     ///
1740     /// If `ignore_up_to` is `Some`, attributes preceding and including that attribute will be
1741     /// assumed to be resolved already.
1742     fn resolve_attributes(&mut self, attrs: &Attrs, mod_item: ModItem) -> Result<(), ()> {
1743         let mut ignore_up_to =
1744             self.def_collector.skip_attrs.get(&InFile::new(self.file_id(), mod_item)).copied();
1745         let iter = attrs
1746             .iter()
1747             .dedup_by(|a, b| {
1748                 // FIXME: this should not be required, all attributes on an item should have a
1749                 // unique ID!
1750                 // Still, this occurs because `#[cfg_attr]` can "expand" to multiple attributes:
1751                 //     #[cfg_attr(not(off), unresolved, unresolved)]
1752                 //     struct S;
1753                 // We should come up with a different way to ID attributes.
1754                 a.id == b.id
1755             })
1756             .skip_while(|attr| match ignore_up_to {
1757                 Some(id) if attr.id == id => {
1758                     ignore_up_to = None;
1759                     true
1760                 }
1761                 Some(_) => true,
1762                 None => false,
1763             });
1764
1765         for attr in iter {
1766             if self.is_builtin_or_registered_attr(&attr.path) {
1767                 continue;
1768             }
1769             tracing::debug!("non-builtin attribute {}", attr.path);
1770
1771             let ast_id = AstIdWithPath::new(
1772                 self.file_id(),
1773                 mod_item.ast_id(self.item_tree),
1774                 attr.path.as_ref().clone(),
1775             );
1776             self.def_collector.unresolved_macros.push(MacroDirective {
1777                 module_id: self.module_id,
1778                 depth: self.macro_depth + 1,
1779                 kind: MacroDirectiveKind::Attr { ast_id, attr: attr.clone(), mod_item },
1780             });
1781
1782             return Err(());
1783         }
1784
1785         Ok(())
1786     }
1787
1788     fn is_builtin_or_registered_attr(&self, path: &ModPath) -> bool {
1789         if path.kind == PathKind::Plain {
1790             if let Some(tool_module) = path.segments().first() {
1791                 let tool_module = tool_module.to_smol_str();
1792                 let is_tool = builtin_attr::TOOL_MODULES
1793                     .iter()
1794                     .copied()
1795                     .chain(self.def_collector.registered_tools.iter().map(SmolStr::as_str))
1796                     .any(|m| tool_module == *m);
1797                 if is_tool {
1798                     return true;
1799                 }
1800             }
1801
1802             if let Some(name) = path.as_ident() {
1803                 let name = name.to_smol_str();
1804                 let is_inert = builtin_attr::INERT_ATTRIBUTES
1805                     .iter()
1806                     .copied()
1807                     .chain(self.def_collector.registered_attrs.iter().map(SmolStr::as_str))
1808                     .any(|attr| name == *attr);
1809                 return is_inert;
1810             }
1811         }
1812
1813         false
1814     }
1815
1816     /// If `attrs` registers a procedural macro, collects its definition.
1817     fn collect_proc_macro_def(&mut self, func_name: &Name, ast_id: AstId<ast::Fn>, attrs: &Attrs) {
1818         // FIXME: this should only be done in the root module of `proc-macro` crates, not everywhere
1819         if let Some(proc_macro) = attrs.parse_proc_macro_decl(func_name) {
1820             self.def_collector.export_proc_macro(proc_macro, ast_id);
1821         }
1822     }
1823
1824     fn collect_macro_rules(&mut self, id: FileItemTreeId<MacroRules>) {
1825         let krate = self.def_collector.def_map.krate;
1826         let mac = &self.item_tree[id];
1827         let attrs = self.item_tree.attrs(self.def_collector.db, krate, ModItem::from(id).into());
1828         let ast_id = InFile::new(self.file_id(), mac.ast_id.upcast());
1829
1830         let export_attr = attrs.by_key("macro_export");
1831
1832         let is_export = export_attr.exists();
1833         let is_local_inner = if is_export {
1834             export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
1835                 tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
1836                     ident.text.contains("local_inner_macros")
1837                 }
1838                 _ => false,
1839             })
1840         } else {
1841             false
1842         };
1843
1844         // Case 1: builtin macros
1845         if attrs.by_key("rustc_builtin_macro").exists() {
1846             // `#[rustc_builtin_macro = "builtin_name"]` overrides the `macro_rules!` name.
1847             let name;
1848             let name = match attrs.by_key("rustc_builtin_macro").string_value() {
1849                 Some(it) => {
1850                     // FIXME: a hacky way to create a Name from string.
1851                     name = tt::Ident { text: it.clone(), id: tt::TokenId::unspecified() }.as_name();
1852                     &name
1853                 }
1854                 None => {
1855                     match attrs.by_key("rustc_builtin_macro").tt_values().next().and_then(|tt| {
1856                         match tt.token_trees.first() {
1857                             Some(tt::TokenTree::Leaf(tt::Leaf::Ident(name))) => Some(name),
1858                             _ => None,
1859                         }
1860                     }) {
1861                         Some(ident) => {
1862                             name = ident.as_name();
1863                             &name
1864                         }
1865                         None => &mac.name,
1866                     }
1867                 }
1868             };
1869             let krate = self.def_collector.def_map.krate;
1870             match find_builtin_macro(name, krate, ast_id) {
1871                 Some(macro_id) => {
1872                     self.def_collector.define_macro_rules(
1873                         self.module_id,
1874                         mac.name.clone(),
1875                         macro_id,
1876                         is_export,
1877                     );
1878                     return;
1879                 }
1880                 None => {
1881                     self.def_collector
1882                         .def_map
1883                         .diagnostics
1884                         .push(DefDiagnostic::unimplemented_builtin_macro(self.module_id, ast_id));
1885                 }
1886             }
1887         }
1888
1889         // Case 2: normal `macro_rules!` macro
1890         let macro_id = MacroDefId {
1891             krate: self.def_collector.def_map.krate,
1892             kind: MacroDefKind::Declarative(ast_id),
1893             local_inner: is_local_inner,
1894         };
1895         self.def_collector.define_macro_rules(
1896             self.module_id,
1897             mac.name.clone(),
1898             macro_id,
1899             is_export,
1900         );
1901     }
1902
1903     fn collect_macro_def(&mut self, id: FileItemTreeId<MacroDef>) {
1904         let krate = self.def_collector.def_map.krate;
1905         let mac = &self.item_tree[id];
1906         let ast_id = InFile::new(self.file_id(), mac.ast_id.upcast());
1907
1908         // Case 1: builtin macros
1909         let attrs = self.item_tree.attrs(self.def_collector.db, krate, ModItem::from(id).into());
1910         if attrs.by_key("rustc_builtin_macro").exists() {
1911             let macro_id = find_builtin_macro(&mac.name, krate, ast_id)
1912                 .or_else(|| find_builtin_derive(&mac.name, krate, ast_id))
1913                 .or_else(|| find_builtin_attr(&mac.name, krate, ast_id));
1914
1915             match macro_id {
1916                 Some(macro_id) => {
1917                     self.def_collector.define_macro_def(
1918                         self.module_id,
1919                         mac.name.clone(),
1920                         macro_id,
1921                         &self.item_tree[mac.visibility],
1922                     );
1923                     return;
1924                 }
1925                 None => {
1926                     self.def_collector
1927                         .def_map
1928                         .diagnostics
1929                         .push(DefDiagnostic::unimplemented_builtin_macro(self.module_id, ast_id));
1930                 }
1931             }
1932         }
1933
1934         // Case 2: normal `macro`
1935         let macro_id = MacroDefId {
1936             krate: self.def_collector.def_map.krate,
1937             kind: MacroDefKind::Declarative(ast_id),
1938             local_inner: false,
1939         };
1940
1941         self.def_collector.define_macro_def(
1942             self.module_id,
1943             mac.name.clone(),
1944             macro_id,
1945             &self.item_tree[mac.visibility],
1946         );
1947     }
1948
1949     fn collect_macro_call(&mut self, mac: &MacroCall) {
1950         let ast_id = AstIdWithPath::new(self.file_id(), mac.ast_id, (*mac.path).clone());
1951
1952         // Case 1: try to resolve in legacy scope and expand macro_rules
1953         let mut error = None;
1954         match macro_call_as_call_id(
1955             &ast_id,
1956             mac.expand_to,
1957             self.def_collector.db,
1958             self.def_collector.def_map.krate,
1959             |path| {
1960                 path.as_ident().and_then(|name| {
1961                     self.def_collector.def_map.with_ancestor_maps(
1962                         self.def_collector.db,
1963                         self.module_id,
1964                         &mut |map, module| map[module].scope.get_legacy_macro(name),
1965                     )
1966                 })
1967             },
1968             &mut |err| {
1969                 error.get_or_insert(err);
1970             },
1971         ) {
1972             Ok(Ok(macro_call_id)) => {
1973                 // Legacy macros need to be expanded immediately, so that any macros they produce
1974                 // are in scope.
1975                 self.def_collector.collect_macro_expansion(
1976                     self.module_id,
1977                     macro_call_id,
1978                     self.macro_depth + 1,
1979                 );
1980
1981                 if let Some(err) = error {
1982                     self.def_collector.def_map.diagnostics.push(DefDiagnostic::macro_error(
1983                         self.module_id,
1984                         MacroCallKind::FnLike { ast_id: ast_id.ast_id, expand_to: mac.expand_to },
1985                         err.to_string(),
1986                     ));
1987                 }
1988
1989                 return;
1990             }
1991             Ok(Err(_)) => {
1992                 // Built-in macro failed eager expansion.
1993
1994                 self.def_collector.def_map.diagnostics.push(DefDiagnostic::macro_error(
1995                     self.module_id,
1996                     MacroCallKind::FnLike { ast_id: ast_id.ast_id, expand_to: mac.expand_to },
1997                     error.unwrap().to_string(),
1998                 ));
1999                 return;
2000             }
2001             Err(UnresolvedMacro { .. }) => (),
2002         }
2003
2004         // Case 2: resolve in module scope, expand during name resolution.
2005         self.def_collector.unresolved_macros.push(MacroDirective {
2006             module_id: self.module_id,
2007             depth: self.macro_depth + 1,
2008             kind: MacroDirectiveKind::FnLike { ast_id, expand_to: mac.expand_to },
2009         });
2010     }
2011
2012     fn import_all_legacy_macros(&mut self, module_id: LocalModuleId) {
2013         let macros = self.def_collector.def_map[module_id].scope.collect_legacy_macros();
2014         for (name, macro_) in macros {
2015             self.def_collector.define_legacy_macro(self.module_id, name.clone(), macro_);
2016         }
2017     }
2018
2019     fn is_cfg_enabled(&self, cfg: &CfgExpr) -> bool {
2020         self.def_collector.cfg_options.check(cfg) != Some(false)
2021     }
2022
2023     fn emit_unconfigured_diagnostic(&mut self, item: ModItem, cfg: &CfgExpr) {
2024         let ast_id = item.ast_id(self.item_tree);
2025
2026         let ast_id = InFile::new(self.file_id(), ast_id);
2027         self.def_collector.def_map.diagnostics.push(DefDiagnostic::unconfigured_code(
2028             self.module_id,
2029             ast_id,
2030             cfg.clone(),
2031             self.def_collector.cfg_options.clone(),
2032         ));
2033     }
2034
2035     fn file_id(&self) -> HirFileId {
2036         self.tree_id.file_id()
2037     }
2038 }
2039
2040 #[cfg(test)]
2041 mod tests {
2042     use crate::{db::DefDatabase, test_db::TestDB};
2043     use base_db::{fixture::WithFixture, SourceDatabase};
2044
2045     use super::*;
2046
2047     fn do_collect_defs(db: &dyn DefDatabase, def_map: DefMap) -> DefMap {
2048         let mut collector = DefCollector {
2049             db,
2050             def_map,
2051             deps: FxHashMap::default(),
2052             glob_imports: FxHashMap::default(),
2053             unresolved_imports: Vec::new(),
2054             resolved_imports: Vec::new(),
2055             unresolved_macros: Vec::new(),
2056             mod_dirs: FxHashMap::default(),
2057             cfg_options: &CfgOptions::default(),
2058             proc_macros: Default::default(),
2059             exports_proc_macros: false,
2060             from_glob_import: Default::default(),
2061             skip_attrs: Default::default(),
2062             derive_helpers_in_scope: Default::default(),
2063             registered_attrs: Default::default(),
2064             registered_tools: Default::default(),
2065         };
2066         collector.seed_with_top_level();
2067         collector.collect();
2068         collector.def_map
2069     }
2070
2071     fn do_resolve(not_ra_fixture: &str) -> DefMap {
2072         let (db, file_id) = TestDB::with_single_file(not_ra_fixture);
2073         let krate = db.test_crate();
2074
2075         let edition = db.crate_graph()[krate].edition;
2076         let module_origin = ModuleOrigin::CrateRoot { definition: file_id };
2077         let def_map = DefMap::empty(krate, edition, module_origin);
2078         do_collect_defs(&db, def_map)
2079     }
2080
2081     #[test]
2082     fn test_macro_expand_will_stop_1() {
2083         do_resolve(
2084             r#"
2085 macro_rules! foo {
2086     ($($ty:ty)*) => { foo!($($ty)*); }
2087 }
2088 foo!(KABOOM);
2089 "#,
2090         );
2091         do_resolve(
2092             r#"
2093 macro_rules! foo {
2094     ($($ty:ty)*) => { foo!(() $($ty)*); }
2095 }
2096 foo!(KABOOM);
2097 "#,
2098         );
2099     }
2100
2101     #[ignore]
2102     #[test]
2103     fn test_macro_expand_will_stop_2() {
2104         // FIXME: this test does succeed, but takes quite a while: 90 seconds in
2105         // the release mode. That's why the argument is not an ra_fixture --
2106         // otherwise injection highlighting gets stuck.
2107         //
2108         // We need to find a way to fail this faster.
2109         do_resolve(
2110             r#"
2111 macro_rules! foo {
2112     ($($ty:ty)*) => { foo!($($ty)* $($ty)*); }
2113 }
2114 foo!(KABOOM);
2115 "#,
2116         );
2117     }
2118 }