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