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