//! The core of the module-level name resolution algorithm. //! //! `DefCollector::collect` contains the fixed-point iteration loop which //! resolves imports and expands macros. use std::{iter, mem, ops::Range}; use base_db::{BuiltDependency, Crate, CrateOrigin, LangCrateOrigin}; use cfg::{CfgAtom, CfgExpr, CfgOptions}; use either::Either; use hir_expand::{ AttrMacroAttrIds, EditionedFileId, ErasedAstId, ExpandTo, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind, attrs::{Attr, AttrId}, builtin::{BuiltinDeriveExpander, find_builtin_attr, find_builtin_derive, find_builtin_macro}, mod_path::{ModPath, PathKind}, name::{AsName, Name}, proc_macro::CustomProcMacroExpander, }; use intern::{Interned, Symbol, sym}; use itertools::izip; use la_arena::Idx; use rustc_hash::{FxHashMap, FxHashSet}; use smallvec::SmallVec; use span::{Edition, FileAstId, SyntaxContext}; use stdx::always; use syntax::ast; use triomphe::Arc; use crate::{ AdtId, AssocItemId, AstId, AstIdWithPath, BuiltinDeriveImplId, BuiltinDeriveImplLoc, ConstLoc, EnumLoc, ExternBlockLoc, ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc, FxIndexMap, ImplLoc, Intern, ItemContainerId, Lookup, Macro2Id, Macro2Loc, MacroExpander, MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ModuleDefId, ModuleId, ProcMacroId, ProcMacroLoc, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc, UnresolvedMacro, UseId, UseLoc, db::DefDatabase, item_scope::{GlobId, ImportId, ImportOrExternCrate, PerNsGlobImports}, item_tree::{ self, Attrs, AttrsOrCfg, FieldsShape, ImportAlias, ImportKind, ItemTree, ItemTreeAstId, Macro2, MacroCall, MacroRules, Mod, ModItemId, ModKind, TreeId, }, macro_call_as_call_id, nameres::{ BuiltinShadowMode, DefMap, LocalDefMap, MacroSubNs, ModuleData, ModuleOrigin, ResolveMode, assoc::TraitItems, attr_resolution::{attr_macro_as_call_id, derive_macro_as_call_id}, crate_def_map, diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::{ReachedFixedPoint, ResolvePathResult}, proc_macro::{ProcMacroDef, ProcMacroKind, parse_macro_name_and_helper_attrs}, sub_namespace_match, }, per_ns::{Item, PerNs}, tt, visibility::{RawVisibility, Visibility}, }; const GLOB_RECURSION_LIMIT: usize = 100; const FIXED_POINT_LIMIT: usize = 8192; pub(super) fn collect_defs( db: &dyn DefDatabase, def_map: DefMap, tree_id: TreeId, crate_local_def_map: Option<&LocalDefMap>, ) -> (DefMap, LocalDefMap) { let krate = &def_map.krate.data(db); let cfg_options = def_map.krate.cfg_options(db); // populate external prelude and dependency list let mut deps = FxIndexMap::with_capacity_and_hasher(krate.dependencies.len(), Default::default()); for dep in &krate.dependencies { tracing::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id); deps.insert(dep.as_name(), dep.clone()); } let proc_macros = if krate.is_proc_macro { db.proc_macros_for_crate(def_map.krate) .and_then(|proc_macros| { proc_macros.list(db.syntax_context(tree_id.file_id(), krate.edition)) }) .unwrap_or_default() } else { Default::default() }; let mut collector = DefCollector { db, def_map, local_def_map: LocalDefMap::default(), crate_local_def_map, deps, glob_imports: FxHashMap::default(), unresolved_imports: Vec::new(), indeterminate_imports: Vec::new(), unresolved_macros: Vec::new(), mod_dirs: FxHashMap::default(), cfg_options, proc_macros, from_glob_import: Default::default(), skip_attrs: Default::default(), prev_active_attrs: Default::default(), unresolved_extern_crates: Default::default(), is_proc_macro: krate.is_proc_macro, deferred_builtin_derives: Default::default(), }; if tree_id.is_block() { collector.seed_with_inner(tree_id); } else { collector.seed_with_top_level(); } collector.collect(); let (mut def_map, mut local_def_map) = collector.finish(); def_map.shrink_to_fit(); local_def_map.shrink_to_fit(); (def_map, local_def_map) } #[derive(Copy, Clone, Debug, Eq, PartialEq)] enum PartialResolvedImport { /// None of any namespaces is resolved Unresolved, /// One of namespaces is resolved Indeterminate(PerNs), /// All namespaces are resolved, OR it comes from other crate Resolved(PerNs), } impl PartialResolvedImport { fn namespaces(self) -> PerNs { match self { PartialResolvedImport::Unresolved => PerNs::none(), PartialResolvedImport::Indeterminate(ns) | PartialResolvedImport::Resolved(ns) => ns, } } } #[derive(Clone, Debug, Eq, PartialEq)] struct ImportSource { use_tree: Idx, id: UseId, is_prelude: bool, kind: ImportKind, } #[derive(Debug, Eq, PartialEq)] struct Import { path: ModPath, alias: Option, visibility: RawVisibility, source: ImportSource, } impl Import { fn from_use( tree: &ItemTree, item: FileAstId, id: UseId, is_prelude: bool, mut cb: impl FnMut(Self), ) { let it = &tree[item]; let visibility = &tree[it.visibility]; it.expand(|idx, path, kind, alias| { cb(Self { path, alias, visibility: visibility.clone(), source: ImportSource { use_tree: idx, id, is_prelude, kind }, }); }); } } #[derive(Debug, Eq, PartialEq)] struct ImportDirective { /// The module this import directive is in. module_id: ModuleId, import: Import, status: PartialResolvedImport, } #[derive(Clone, Debug, Eq, PartialEq)] struct MacroDirective<'db> { module_id: ModuleId, depth: usize, kind: MacroDirectiveKind<'db>, container: ItemContainerId, } #[derive(Clone, Debug, Eq, PartialEq)] enum MacroDirectiveKind<'db> { FnLike { ast_id: AstIdWithPath, expand_to: ExpandTo, ctxt: SyntaxContext, }, Derive { ast_id: AstIdWithPath, derive_attr: AttrId, derive_pos: usize, ctxt: SyntaxContext, /// The "parent" macro it is resolved to. derive_macro_id: MacroCallId, }, Attr { ast_id: AstIdWithPath, attr_id: AttrId, attr: Attr, mod_item: ModItemId, /* is this needed? */ tree: TreeId, item_tree: &'db ItemTree, }, } #[derive(Debug)] struct DeferredBuiltinDerive { call_id: MacroCallId, derive: BuiltinDeriveExpander, module_id: ModuleId, depth: usize, container: ItemContainerId, derive_attr_id: AttrId, derive_index: u32, helpers_range: Range, } /// Walks the tree of module recursively struct DefCollector<'db> { db: &'db dyn DefDatabase, def_map: DefMap, local_def_map: LocalDefMap, /// Set only in case of blocks. crate_local_def_map: Option<&'db LocalDefMap>, // The dependencies of the current crate, including optional deps like `test`. deps: FxIndexMap, glob_imports: FxHashMap>, unresolved_imports: Vec, indeterminate_imports: Vec<(ImportDirective, PerNs)>, unresolved_macros: Vec>, // We'd like to avoid emitting a diagnostics avalanche when some `extern crate` doesn't // resolve. When we emit diagnostics for unresolved imports, we only do so if the import // doesn't start with an unresolved crate's name. unresolved_extern_crates: FxHashSet, mod_dirs: FxHashMap, cfg_options: &'db CfgOptions, /// List of procedural macros defined by this crate. This is read from the dynamic library /// built by the build system, and is the list of proc-macros we can actually expand. It is /// empty when proc-macro support is disabled (in which case we still do name resolution for /// them). The bool signals whether the proc-macro has been explicitly disabled for name-resolution. proc_macros: Box<[(Name, CustomProcMacroExpander, bool)]>, is_proc_macro: bool, from_glob_import: PerNsGlobImports, /// If we fail to resolve an attribute on a `ModItem`, we fall back to ignoring the attribute. /// This map is used to skip all attributes up to and including the one that failed to resolve, /// in order to not expand them twice. /// /// This also stores the attributes to skip when we resolve derive helpers and non-macro /// non-builtin attributes in general. // FIXME: There has to be a better way to do this skip_attrs: FxHashMap, AttrId>, /// When we expand attributes, we need to censor all previous active attributes /// on the same item. Therefore, this holds all active attributes that we already /// expanded. prev_active_attrs: FxHashMap, SmallVec<[AttrId; 1]>>, /// To save memory, we do not really expand builtin derives. Instead, we save them as a `BuiltinDeriveImplId`. /// /// However, we can only do that when the derive is directly above the item, and there is no attribute in between. /// Otherwise, all sorts of weird things can happen, like the item name resolving to something else. deferred_builtin_derives: FxHashMap, Vec>, } impl<'db> DefCollector<'db> { fn seed_with_top_level(&mut self) { let _p = tracing::info_span!("seed_with_top_level").entered(); let file_id = self.def_map.krate.root_file_id(self.db); let item_tree = self.db.file_item_tree(file_id.into()); let attrs = match item_tree.top_level_attrs() { AttrsOrCfg::Enabled { attrs } => attrs.as_ref(), AttrsOrCfg::CfgDisabled(it) => it.1.as_ref(), }; let crate_data = Arc::get_mut(&mut self.def_map.data).unwrap(); // Process other crate-level attributes. for attr in &*attrs { let Some(attr_name) = attr.path.as_ident() else { continue }; match () { () if *attr_name == sym::recursion_limit => { if let Some(limit) = attr.string_value() && let Ok(limit) = limit.parse() { crate_data.recursion_limit = Some(limit); } } () if *attr_name == sym::crate_type => { if attr.string_value() == Some("proc-macro") { self.is_proc_macro = true; } } () if *attr_name == sym::no_core => crate_data.no_core = true, () if *attr_name == sym::no_std => crate_data.no_std = true, () if *attr_name == sym::rustc_coherence_is_core => { crate_data.rustc_coherence_is_core = true; } () if *attr_name == sym::feature => { let features = attr.parse_path_comma_token_tree(self.db).into_iter().flatten().filter_map( |(feat, _, _)| match feat.segments() { [name] => Some(name.symbol().clone()), _ => None, }, ); crate_data.unstable_features.extend(features); } () if *attr_name == sym::register_tool => { if let Some(ident) = attr.single_ident_value() { crate_data.registered_tools.push(ident.sym.clone()); cov_mark::hit!(register_tool); } } () => (), } } for (name, dep) in &self.deps { // Add all if dep.is_prelude() { // This is a bit confusing but the gist is that `no_core` and `no_std` remove the // sysroot dependence on `core` and `std` respectively. Our `CrateGraph` is eagerly // constructed with them in place no matter what though, since at that point we // don't do pre-configured attribute resolution yet. // So here check if we are no_core / no_std and we are trying to add the // corresponding dep from the sysroot // Depending on the crate data of a dependency seems bad for incrementality, but // we only do that for sysroot crates (this is why the order of the `&&` is important) // - which are normally standard library crate, which realistically aren't going // to have their crate ID invalidated, because they stay on the same root file and // they're dependencies of everything else, so if some collision miraculously occurs // we will resolve it by disambiguating the other crate. let skip = dep.is_sysroot() && match dep.crate_id.data(self.db).origin { CrateOrigin::Lang(LangCrateOrigin::Core) => crate_data.no_core, CrateOrigin::Lang(LangCrateOrigin::Std) => { crate_data.no_core || crate_data.no_std } _ => false, }; if skip { continue; } // This eagerly draws a dependency edge between the crate def maps even if the // things the crates are not used. This is not great, but at the same time we would // like to compute our dependency def maps in parallel here anyways in the future // which will have the same effect. self.local_def_map.extern_prelude.insert( name.clone(), (crate_def_map(self.db, dep.crate_id).root_module_id(), None), ); } } self.inject_prelude(); if matches!(item_tree.top_level_attrs(), AttrsOrCfg::CfgDisabled(_)) { return; } let module_id = self.def_map.root; ModCollector { def_collector: self, macro_depth: 0, module_id, tree_id: TreeId::new(file_id.into(), None), item_tree, mod_dir: ModDir::root(), } .collect_in_top_module(item_tree.top_level_items()); Arc::get_mut(&mut self.def_map.data).unwrap().shrink_to_fit(); } fn seed_with_inner(&mut self, tree_id: TreeId) { let item_tree = tree_id.item_tree(self.db); let is_cfg_enabled = matches!(item_tree.top_level_attrs(), AttrsOrCfg::Enabled { .. }); if is_cfg_enabled { self.inject_prelude(); let module_id = self.def_map.root; ModCollector { def_collector: self, macro_depth: 0, module_id, tree_id, item_tree, mod_dir: ModDir::root(), } .collect_in_top_module(item_tree.top_level_items()); } } fn resolution_loop(&mut self) { let _p = tracing::info_span!("DefCollector::resolution_loop").entered(); // main name resolution fixed-point loop. let mut i = 0; 'resolve_attr: loop { let _p = tracing::info_span!("resolve_macros loop").entered(); 'resolve_macros: loop { self.db.unwind_if_revision_cancelled(); { let _p = tracing::info_span!("resolve_imports loop").entered(); 'resolve_imports: loop { if self.resolve_imports() == ReachedFixedPoint::Yes { break 'resolve_imports; } } } if self.resolve_macros() == ReachedFixedPoint::Yes { break 'resolve_macros; } i += 1; if i > FIXED_POINT_LIMIT { tracing::error!("name resolution is stuck"); break 'resolve_attr; } } if self.reseed_with_unresolved_attribute() == ReachedFixedPoint::Yes { break 'resolve_attr; } } } fn collect(&mut self) { let _p = tracing::info_span!("DefCollector::collect").entered(); self.resolution_loop(); let unresolved_imports = mem::take(&mut self.unresolved_imports); // show unresolved imports in completion, etc for directive in &unresolved_imports { self.record_resolved_import(directive); } self.unresolved_imports = unresolved_imports; if self.is_proc_macro { // A crate exporting procedural macros is not allowed to export anything else. // // Additionally, while the proc macro entry points must be `pub`, they are not publicly // exported in type/value namespace. This function reduces the visibility of all items // in the crate root that aren't proc macros. let module_id = self.def_map.root_module_id(); let root = &mut self.def_map.modules[module_id]; root.scope.censor_non_proc_macros(self.def_map.krate); } } /// When the fixed-point loop reaches a stable state, we might still have /// some unresolved attributes left over. This takes one of them, and feeds /// the item it's applied to back into name resolution. /// /// This effectively ignores the fact that the macro is there and just treats the items as /// normal code. /// /// This improves UX for unresolved attributes, and replicates the /// behavior before we supported proc. attribute macros. fn reseed_with_unresolved_attribute(&mut self) -> ReachedFixedPoint { cov_mark::hit!(unresolved_attribute_fallback); let unresolved_attr = self.unresolved_macros.iter().enumerate().find_map(|(idx, directive)| match &directive .kind { MacroDirectiveKind::Attr { ast_id, mod_item, attr_id, attr, tree, item_tree } => { self.def_map.diagnostics.push(DefDiagnostic::unresolved_macro_call( directive.module_id, MacroCallKind::Attr { ast_id: ast_id.ast_id, attr_args: None, censored_attr_ids: AttrMacroAttrIds::from_one(*attr_id), }, (*attr.path).clone(), )); self.skip_attrs.insert(ast_id.ast_id.with_value(mod_item.ast_id()), *attr_id); Some((idx, directive, *mod_item, *tree, *item_tree)) } _ => None, }); match unresolved_attr { Some(( pos, &MacroDirective { module_id, depth, container, .. }, mod_item, tree_id, item_tree, )) => { // FIXME: Remove this clone let mod_dir = self.mod_dirs[&module_id].clone(); ModCollector { def_collector: self, macro_depth: depth, module_id, tree_id, item_tree, mod_dir, } .collect(&[mod_item], container); self.unresolved_macros.swap_remove(pos); // Continue name resolution with the new data. ReachedFixedPoint::No } None => ReachedFixedPoint::Yes, } } fn inject_prelude(&mut self) { // See compiler/rustc_builtin_macros/src/standard_library_imports.rs if self.def_map.data.no_core { // libcore does not get a prelude. return; } let krate = if self.def_map.data.no_std { Name::new_symbol_root(sym::core) } else if self.local_def_map().extern_prelude().any(|(name, _)| *name == sym::std) { Name::new_symbol_root(sym::std) } else { // If `std` does not exist for some reason, fall back to core. This mostly helps // keep r-a's own tests minimal. Name::new_symbol_root(sym::core) }; let edition = match self.def_map.data.edition { Edition::Edition2015 => Name::new_symbol_root(sym::rust_2015), Edition::Edition2018 => Name::new_symbol_root(sym::rust_2018), Edition::Edition2021 => Name::new_symbol_root(sym::rust_2021), Edition::Edition2024 => Name::new_symbol_root(sym::rust_2024), }; let path_kind = match self.def_map.data.edition { Edition::Edition2015 => PathKind::Plain, _ => PathKind::Abs, }; let path = ModPath::from_segments( path_kind, [krate, Name::new_symbol_root(sym::prelude), edition], ); let (per_ns, _) = self.def_map.resolve_path( self.crate_local_def_map.unwrap_or(&self.local_def_map), self.db, self.def_map.root_module_id(), &path, BuiltinShadowMode::Other, None, ); match per_ns.types { Some(Item { def: ModuleDefId::ModuleId(m), import, .. }) => { self.def_map.prelude = Some((m, import.and_then(ImportOrExternCrate::use_))); } types => { tracing::debug!( "could not resolve prelude path `{}` to module (resolved to {:?})", path.display(self.db, Edition::LATEST), types ); } } } fn local_def_map(&mut self) -> &LocalDefMap { self.crate_local_def_map.unwrap_or(&self.local_def_map) } /// Adds a definition of procedural macro `name` to the root module. /// /// # Notes on procedural macro resolution /// /// Procedural macro functionality is provided by the build system: It has to build the proc /// macro and pass the resulting dynamic library to rust-analyzer. /// /// When procedural macro support is enabled, the list of proc macros exported by a crate is /// known before we resolve names in the crate. This list is stored in `self.proc_macros` and is /// derived from the dynamic library. /// /// However, we *also* would like to be able to at least *resolve* macros on our own, without /// help by the build system. So, when the macro isn't found in `self.proc_macros`, we instead /// use a dummy expander that always errors. This comes with the drawback of macros potentially /// going out of sync with what the build system sees (since we resolve using VFS state, but /// Cargo builds only on-disk files). We could and probably should add diagnostics for that. fn export_proc_macro(&mut self, def: ProcMacroDef, ast_id: AstId, fn_id: FunctionId) { let kind = def.kind.to_basedb_kind(); let (expander, kind) = match self.proc_macros.iter().find(|(n, _, _)| n == &def.name) { Some(_) if kind == hir_expand::proc_macro::ProcMacroKind::Attr && !self.db.expand_proc_attr_macros() => { (CustomProcMacroExpander::disabled_proc_attr(), kind) } Some(&(_, _, true)) => (CustomProcMacroExpander::disabled(), kind), Some(&(_, expander, false)) => (expander, kind), None => (CustomProcMacroExpander::missing_expander(), kind), }; let proc_macro_id = ProcMacroLoc { container: self.def_map.root_module_id(), id: ast_id, expander, kind, edition: self.def_map.data.edition, } .intern(self.db); self.def_map.macro_def_to_macro_id.insert(ast_id.erase(), proc_macro_id.into()); self.define_proc_macro(def.name.clone(), proc_macro_id); let crate_data = Arc::get_mut(&mut self.def_map.data).unwrap(); if let ProcMacroKind::Derive { helpers } = def.kind { crate_data.exported_derives.insert(proc_macro_id.into(), helpers); } crate_data.fn_proc_macro_mapping.insert(fn_id, proc_macro_id); crate_data.fn_proc_macro_mapping_back.insert(proc_macro_id, fn_id); } /// Define a macro with `macro_rules`. /// /// It will define the macro in legacy textual scope, and if it has `#[macro_export]`, /// then it is also defined in the root module scope. /// You can `use` or invoke it by `crate::macro_name` anywhere, before or after the definition. /// /// It is surprising that the macro will never be in the current module scope. /// These code fails with "unresolved import/macro", /// ```rust,compile_fail /// mod m { macro_rules! foo { () => {} } } /// use m::foo as bar; /// ``` /// /// ```rust,compile_fail /// macro_rules! foo { () => {} } /// self::foo!(); /// crate::foo!(); /// ``` /// /// Well, this code compiles, because the plain path `foo` in `use` is searched /// in the legacy textual scope only. /// ```rust /// macro_rules! foo { () => {} } /// use foo as bar; /// ``` fn define_macro_rules( &mut self, module_id: ModuleId, name: Name, macro_: MacroRulesId, export: bool, ) { // Textual scoping self.define_legacy_macro(module_id, name.clone(), macro_.into()); // Module scoping // In Rust, `#[macro_export]` macros are unconditionally visible at the // crate root, even if the parent modules is **not** visible. if export { let module_id = self.def_map.root; self.def_map.modules[module_id].scope.declare(macro_.into()); self.update( module_id, &[(Some(name), PerNs::macros(macro_.into(), Visibility::Public, None))], Visibility::Public, None, ); } } /// Define a legacy textual scoped macro in module /// /// We use a map `legacy_macros` to store all legacy textual scoped macros visible per module. /// It will clone all macros from parent legacy scope, whose definition is prior to /// the definition of current module. /// And also, `macro_use` on a module will import all legacy macros visible inside to /// current legacy scope, with possible shadowing. fn define_legacy_macro(&mut self, module_id: ModuleId, name: Name, mac: MacroId) { // Always shadowing self.def_map.modules[module_id].scope.define_legacy_macro(name, mac); } /// Define a macro 2.0 macro /// /// The scoped of macro 2.0 macro is equal to normal function fn define_macro_def( &mut self, module_id: ModuleId, name: Name, macro_: Macro2Id, vis: &RawVisibility, ) { let vis = self .def_map .resolve_visibility( self.crate_local_def_map.unwrap_or(&self.local_def_map), self.db, module_id, vis, false, ) .unwrap_or(Visibility::Public); self.def_map.modules[module_id].scope.declare(macro_.into()); self.update( module_id, &[(Some(name), PerNs::macros(macro_.into(), Visibility::Public, None))], vis, None, ); } /// Define a proc macro /// /// A proc macro is similar to normal macro scope, but it would not visible in legacy textual scoped. /// And unconditionally exported. fn define_proc_macro(&mut self, name: Name, macro_: ProcMacroId) { let module_id = self.def_map.root; self.def_map.modules[module_id].scope.declare(macro_.into()); self.update( module_id, &[(Some(name), PerNs::macros(macro_.into(), Visibility::Public, None))], Visibility::Public, None, ); } /// Import exported macros from another crate. `names`, if `Some(_)`, specifies the name of /// macros to be imported. Otherwise this method imports all exported macros. /// /// Exported macros are just all macros in the root module scope. /// Note that it contains not only all `#[macro_export]` macros, but also all aliases /// created by `use` in the root module, ignoring the visibility of `use`. fn import_macros_from_extern_crate( &mut self, krate: Crate, names: Option>, extern_crate: Option, ) { let def_map = crate_def_map(self.db, krate); // `#[macro_use]` brings macros into macro_use prelude. Yes, even non-`macro_rules!` // macros. let root_scope = &def_map[def_map.root].scope; match names { Some(names) => { for name in names { // FIXME: Report diagnostic on 404. if let Some(def) = root_scope.get(&name).take_macros() { self.def_map.macro_use_prelude.insert(name, (def, extern_crate)); } } } None => { for (name, it) in root_scope.macros() { self.def_map.macro_use_prelude.insert(name.clone(), (it.def, extern_crate)); } } } } /// Tries to resolve every currently unresolved import. fn resolve_imports(&mut self) -> ReachedFixedPoint { let mut res = ReachedFixedPoint::Yes; let imports = mem::take(&mut self.unresolved_imports); self.unresolved_imports = imports .into_iter() .filter_map(|mut directive| { directive.status = self.resolve_import(directive.module_id, &directive.import); match directive.status { PartialResolvedImport::Indeterminate(resolved) => { self.record_resolved_import(&directive); self.indeterminate_imports.push((directive, resolved)); res = ReachedFixedPoint::No; None } PartialResolvedImport::Resolved(_) => { self.record_resolved_import(&directive); res = ReachedFixedPoint::No; None } PartialResolvedImport::Unresolved => Some(directive), } }) .collect(); // Resolve all indeterminate resolved imports again // As some of the macros will expand newly import shadowing partial resolved imports // FIXME: We maybe could skip this, if we handle the indeterminate imports in `resolve_imports` // correctly let mut indeterminate_imports = std::mem::take(&mut self.indeterminate_imports); indeterminate_imports.retain_mut(|(directive, partially_resolved)| { let partially_resolved = partially_resolved.availability(); directive.status = self.resolve_import(directive.module_id, &directive.import); match directive.status { PartialResolvedImport::Indeterminate(import) if partially_resolved != import.availability() => { self.record_resolved_import(directive); res = ReachedFixedPoint::No; false } PartialResolvedImport::Resolved(_) => { self.record_resolved_import(directive); res = ReachedFixedPoint::No; false } _ => true, } }); self.indeterminate_imports = indeterminate_imports; res } fn resolve_import(&self, module_id: ModuleId, import: &Import) -> PartialResolvedImport { let _p = tracing::info_span!("resolve_import", import_path = %import.path.display(self.db, Edition::LATEST)) .entered(); tracing::debug!("resolving import: {:?} ({:?})", import, self.def_map.data.edition); let ResolvePathResult { resolved_def, segment_index, reached_fixedpoint, prefix_info } = self.def_map.resolve_path_fp_with_macro( self.crate_local_def_map.unwrap_or(&self.local_def_map), self.db, ResolveMode::Import, module_id, &import.path, BuiltinShadowMode::Module, None, // An import may resolve to any kind of macro. ); if reached_fixedpoint == ReachedFixedPoint::No || resolved_def.is_none() || segment_index.is_some() { return PartialResolvedImport::Unresolved; } if prefix_info.differing_crate { return PartialResolvedImport::Resolved( resolved_def.filter_visibility(|v| matches!(v, Visibility::Public)), ); } // Check whether all namespaces are resolved. if resolved_def.is_full() { PartialResolvedImport::Resolved(resolved_def) } else { PartialResolvedImport::Indeterminate(resolved_def) } } fn record_resolved_import(&mut self, directive: &ImportDirective) { let _p = tracing::info_span!("record_resolved_import").entered(); let module_id = directive.module_id; let import = &directive.import; let mut def = directive.status.namespaces(); let vis = self .def_map .resolve_visibility( self.crate_local_def_map.unwrap_or(&self.local_def_map), self.db, module_id, &directive.import.visibility, false, ) .unwrap_or(Visibility::Public); match import.source { ImportSource { kind: kind @ (ImportKind::Plain | ImportKind::TypeOnly), id, use_tree, .. } => { let name = match &import.alias { Some(ImportAlias::Alias(name)) => Some(name), Some(ImportAlias::Underscore) => None, None => match import.path.segments().last() { Some(last_segment) => Some(last_segment), None => { cov_mark::hit!(bogus_paths); return; } }, }; if kind == ImportKind::TypeOnly { def.values = None; def.macros = None; } let imp = ImportOrExternCrate::Import(ImportId { use_: id, idx: use_tree }); tracing::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def); // `extern crate crate_name` things can be re-exported as `pub use crate_name`. // But they cannot be re-exported as `pub use self::crate_name`, `pub use crate::crate_name` // or `pub use ::crate_name`. // // This has been historically allowed, but may be not allowed in future // https://github.com/rust-lang/rust/issues/127909 if let Some(def) = def.types.as_mut() { let is_extern_crate_reimport_without_prefix = || { let Some(ImportOrExternCrate::ExternCrate(_)) = def.import else { return false; }; if kind == ImportKind::Glob { return false; } matches!(import.path.kind, PathKind::Plain | PathKind::SELF) && import.path.segments().len() < 2 }; if is_extern_crate_reimport_without_prefix() { def.vis = vis; } } self.update(module_id, &[(name.cloned(), def)], vis, Some(imp)); } ImportSource { kind: ImportKind::Glob, id, is_prelude, use_tree, .. } => { tracing::debug!("glob import: {:?}", import); let glob = GlobId { use_: id, idx: use_tree }; match def.take_types() { Some(ModuleDefId::ModuleId(m)) => { if is_prelude { // Note: This dodgily overrides the injected prelude. The rustc // implementation seems to work the same though. cov_mark::hit!(std_prelude); self.def_map.prelude = Some((m, Some(id))); } else if m.krate(self.db) != self.def_map.krate { cov_mark::hit!(glob_across_crates); // glob import from other crate => we can just import everything once let scope = &m.def_map(self.db)[m].scope; // Module scoped macros is included let items = scope .resolutions() // only keep visible names... .map(|(n, res)| { (n, res.filter_visibility(|v| v.is_visible_from_other_crate())) }) .filter(|(_, res)| !res.is_none()) .collect::>(); self.update( module_id, &items, vis, Some(ImportOrExternCrate::Glob(glob)), ); } else { // glob import from same crate => we do an initial // import, and then need to propagate any further // additions let scope = if m.block(self.db) == self.def_map.block_id() { &self.def_map[m].scope } else { &m.def_map(self.db)[m].scope }; // Module scoped macros is included let items = scope .resolutions() // only keep visible names... .map(|(n, res)| { ( n, res.filter_visibility(|v| { v.is_visible_from_def_map( self.db, &self.def_map, module_id, ) }), ) }) .filter(|(_, res)| !res.is_none()) .collect::>(); self.update( module_id, &items, vis, Some(ImportOrExternCrate::Glob(glob)), ); // record the glob import in case we add further items let glob_imports = self.glob_imports.entry(m).or_default(); match glob_imports.iter_mut().find(|(mid, _, _)| *mid == module_id) { None => glob_imports.push((module_id, vis, glob)), Some((_, old_vis, _)) => { if let Some(new_vis) = old_vis.max(self.db, vis, &self.def_map) { *old_vis = new_vis; } } } } } Some(ModuleDefId::AdtId(AdtId::EnumId(e))) => { cov_mark::hit!(glob_enum); // glob import from enum => just import all the variants let resolutions = e .enum_variants(self.db) .variants .iter() .map(|&(variant, ref name, _)| { let res = PerNs::both(variant.into(), variant.into(), vis, None); (Some(name.clone()), res) }) .collect::>(); self.update( module_id, &resolutions, vis, Some(ImportOrExternCrate::Glob(glob)), ); } Some(ModuleDefId::TraitId(it)) => { // FIXME: Implement this correctly // We can't actually call `trait_items`, the reason being that if macro calls // occur, they will call back into the def map which we might be computing right // now resulting in a cycle. // To properly implement this, trait item collection needs to be done in def map // collection... let resolutions = if true { vec![] } else { TraitItems::query(self.db, it) .items .iter() .map(|&(ref name, variant)| { let res = match variant { AssocItemId::FunctionId(it) => { PerNs::values(it.into(), vis, None) } AssocItemId::ConstId(it) => { PerNs::values(it.into(), vis, None) } AssocItemId::TypeAliasId(it) => { PerNs::types(it.into(), vis, None) } }; (Some(name.clone()), res) }) .collect::>() }; self.update( module_id, &resolutions, vis, Some(ImportOrExternCrate::Glob(glob)), ); } Some(d) => { tracing::debug!("glob import {:?} from non-module/enum {:?}", import, d); } None => { tracing::debug!("glob import {:?} didn't resolve as type", import); } } } } } fn update( &mut self, // The module for which `resolutions` have been resolve module_id: ModuleId, resolutions: &[(Option, PerNs)], // Visibility this import will have vis: Visibility, import: Option, ) { self.update_recursive(module_id, resolutions, vis, import, 0) } fn update_recursive( &mut self, // The module for which `resolutions` have been resolved. module_id: ModuleId, resolutions: &[(Option, PerNs)], // All resolutions are imported with this visibility; the visibilities in // the `PerNs` values are ignored and overwritten vis: Visibility, import: Option, depth: usize, ) { if depth > GLOB_RECURSION_LIMIT { // prevent stack overflows (but this shouldn't be possible) panic!("infinite recursion in glob imports!"); } let mut changed = false; for (name, res) in resolutions { match name { Some(name) => { changed |= self.push_res_and_update_glob_vis(module_id, name, *res, vis, import); } None => { let (tr, import) = match res.take_types_full() { Some(Item { def: ModuleDefId::TraitId(tr), vis: _, import }) => { (tr, import) } Some(other) => { tracing::debug!("non-trait `_` import of {:?}", other); continue; } None => continue, }; let old_vis = self.def_map.modules[module_id].scope.unnamed_trait_vis(tr); let should_update = match old_vis { None => true, Some(old_vis) => { let max_vis = old_vis.max(self.db, vis, &self.def_map).unwrap_or_else(|| { panic!("`Tr as _` imports with unrelated visibilities {old_vis:?} and {vis:?} (trait {tr:?})"); }); if max_vis == old_vis { false } else { cov_mark::hit!(upgrade_underscore_visibility); true } } }; if should_update { changed = true; self.def_map.modules[module_id].scope.push_unnamed_trait( tr, vis, import.and_then(ImportOrExternCrate::import), ); } } } } if !changed { return; } let glob_imports = self .glob_imports .get(&module_id) .into_iter() .flatten() .filter(|(glob_importing_module, _, _)| { // we know all resolutions have the same visibility (`vis`), so we // just need to check that once vis.is_visible_from_def_map(self.db, &self.def_map, *glob_importing_module) }) .cloned() .collect::>(); for (glob_importing_module, glob_import_vis, glob) in glob_imports { let vis = glob_import_vis.min(self.db, vis, &self.def_map).unwrap_or(glob_import_vis); self.update_recursive( glob_importing_module, resolutions, vis, Some(ImportOrExternCrate::Glob(glob)), depth + 1, ); } } fn push_res_and_update_glob_vis( &mut self, module_id: ModuleId, name: &Name, mut defs: PerNs, vis: Visibility, def_import_type: Option, ) -> bool { if let Some(def) = defs.types.as_mut() { def.vis = def.vis.min(self.db, vis, &self.def_map).unwrap_or(vis); } if let Some(def) = defs.values.as_mut() { def.vis = def.vis.min(self.db, vis, &self.def_map).unwrap_or(vis); } if let Some(def) = defs.macros.as_mut() { def.vis = def.vis.min(self.db, vis, &self.def_map).unwrap_or(vis); } let mut changed = false; if let Some(ImportOrExternCrate::Glob(_)) = def_import_type { let prev_defs = self.def_map[module_id].scope.get(name); // Multiple globs may import the same item and they may override visibility from // previously resolved globs. Handle overrides here and leave the rest to // `ItemScope::push_res_with_import()`. if let Some(def) = defs.types && let Some(prev_def) = prev_defs.types { if def.def == prev_def.def && self.from_glob_import.contains_type(module_id, name.clone()) && def.vis != prev_def.vis && def.vis.max(self.db, prev_def.vis, &self.def_map) == Some(def.vis) { changed = true; // This import is being handled here, don't pass it down to // `ItemScope::push_res_with_import()`. defs.types = None; self.def_map.modules[module_id].scope.update_visibility_types(name, def.vis); } // When the source module's definition changed (e.g., due to an explicit import // shadowing a glob), propagate the new definition to modules that glob-import from it. // We check that the previous definition came from the same glob import to avoid // incorrectly overwriting definitions from different glob sources. // // Note this is not a perfect fix, but it makes // https://github.com/rust-lang/rust-analyzer/issues/19224 work for now until we // implement a proper glob graph else if def.def != prev_def.def && prev_def.import == def_import_type { changed = true; defs.types = None; self.def_map.modules[module_id].scope.update_def_types(name, def.def, def.vis); } } if let Some(def) = defs.values && let Some(prev_def) = prev_defs.values { if def.def == prev_def.def && self.from_glob_import.contains_value(module_id, name.clone()) && def.vis != prev_def.vis && def.vis.max(self.db, prev_def.vis, &self.def_map) == Some(def.vis) { changed = true; defs.values = None; self.def_map.modules[module_id].scope.update_visibility_values(name, def.vis); } else if def.def != prev_def.def && prev_def.import.map(ImportOrExternCrate::from) == def_import_type { changed = true; defs.values = None; self.def_map.modules[module_id].scope.update_def_values(name, def.def, def.vis); } } if let Some(def) = defs.macros && let Some(prev_def) = prev_defs.macros { if def.def == prev_def.def && self.from_glob_import.contains_macro(module_id, name.clone()) && def.vis != prev_def.vis && def.vis.max(self.db, prev_def.vis, &self.def_map) == Some(def.vis) { changed = true; defs.macros = None; self.def_map.modules[module_id].scope.update_visibility_macros(name, def.vis); } else if def.def != prev_def.def && prev_def.import == def_import_type { changed = true; defs.macros = None; self.def_map.modules[module_id].scope.update_def_macros(name, def.def, def.vis); } } } changed |= self.def_map.modules[module_id].scope.push_res_with_import( &mut self.from_glob_import, (module_id, name.clone()), defs, def_import_type, ); changed } fn resolve_macros(&mut self) -> ReachedFixedPoint { let mut macros = mem::take(&mut self.unresolved_macros); let mut resolved = Vec::new(); let push_resolved = |resolved: &mut Vec<_>, directive: &MacroDirective<'_>, call_id| { let attr_macro_item = match &directive.kind { MacroDirectiveKind::Attr { ast_id, .. } => Some(ast_id.ast_id), MacroDirectiveKind::FnLike { .. } | MacroDirectiveKind::Derive { .. } => None, }; resolved.push(( directive.module_id, directive.depth, directive.container, call_id, attr_macro_item, )); }; #[derive(PartialEq, Eq)] enum Resolved { Yes, No, } let mut eager_callback_buffer = vec![]; let mut res = ReachedFixedPoint::Yes; // Retain unresolved macros after this round of resolution. let mut retain = |directive: &MacroDirective<'db>| { let subns = match &directive.kind { MacroDirectiveKind::FnLike { .. } => MacroSubNs::Bang, MacroDirectiveKind::Attr { .. } | MacroDirectiveKind::Derive { .. } => { MacroSubNs::Attr } }; let resolver = |def_map: &DefMap, path: &_| { let resolved_res = def_map.resolve_path_fp_with_macro( self.crate_local_def_map.unwrap_or(&self.local_def_map), self.db, ResolveMode::Other, directive.module_id, path, BuiltinShadowMode::Module, Some(subns), ); resolved_res.resolved_def.take_macros().map(|it| (it, self.db.macro_def(it))) }; let resolver_def_id = |path: &_| resolver(&self.def_map, path).map(|(_, it)| it); match &directive.kind { MacroDirectiveKind::FnLike { ast_id, expand_to, ctxt: call_site } => { let call_id = macro_call_as_call_id( self.db, ast_id.ast_id, &ast_id.path, *call_site, *expand_to, self.def_map.krate, resolver_def_id, &mut |ptr, call_id| { eager_callback_buffer.push((directive.module_id, ptr, call_id)); }, ); if let Ok(call_id) = call_id { // FIXME: Expansion error if let Some(call_id) = call_id.value { self.def_map.modules[directive.module_id] .scope .add_macro_invoc(ast_id.ast_id, call_id); push_resolved(&mut resolved, directive, call_id); res = ReachedFixedPoint::No; return Resolved::Yes; } } } MacroDirectiveKind::Derive { ast_id, derive_attr, derive_pos, ctxt: call_site, derive_macro_id, } => { // FIXME: This code is almost duplicate below. let id = derive_macro_as_call_id( self.db, ast_id, *derive_attr, *derive_pos as u32, *call_site, self.def_map.krate, |path| resolver(&self.def_map, path), *derive_macro_id, ); if let Ok((macro_id, def_id, call_id)) = id { self.def_map.modules[directive.module_id].scope.set_derive_macro_invoc( ast_id.ast_id, Either::Left(call_id), *derive_attr, *derive_pos, ); // Record its helper attributes. if def_id.krate != self.def_map.krate { let def_map = crate_def_map(self.db, def_id.krate); if let Some(helpers) = def_map.data.exported_derives.get(¯o_id) { self.def_map .derive_helpers_in_scope .entry(ast_id.ast_id.map(|it| it.upcast())) .or_default() .extend(izip!( helpers.iter().cloned(), iter::repeat(macro_id), iter::repeat(Either::Left(call_id)), )); } } push_resolved(&mut resolved, directive, call_id); res = ReachedFixedPoint::No; return Resolved::Yes; } } MacroDirectiveKind::Attr { ast_id: file_ast_id, mod_item, attr_id, attr, tree, item_tree, } => { let &AstIdWithPath { ast_id, ref path } = file_ast_id; let file_id = ast_id.file_id; let mut recollect_without = |collector: &mut Self| { // Remove the original directive since we resolved it. let mod_dir = collector.mod_dirs[&directive.module_id].clone(); collector .skip_attrs .insert(InFile::new(file_id, mod_item.ast_id()), *attr_id); ModCollector { def_collector: collector, macro_depth: directive.depth, module_id: directive.module_id, tree_id: *tree, item_tree, mod_dir, } .collect(&[*mod_item], directive.container); res = ReachedFixedPoint::No; Resolved::Yes }; if let Some(ident) = path.as_ident() && let Some(helpers) = self.def_map.derive_helpers_in_scope.get(&ast_id) && helpers.iter().any(|(it, ..)| it == ident) { cov_mark::hit!(resolved_derive_helper); // Resolved to derive helper. Collect the item's attributes again, // starting after the derive helper. return recollect_without(self); } let def = match resolver_def_id(path) { Some(def) if def.is_attribute() => def, _ => return Resolved::No, }; // Skip #[test]/#[bench]/#[test_case] expansion, which would merely result in more memory usage // due to duplicating functions into macro expansions, but only if `cfg(test)` is active, // otherwise they are expanded to nothing and this can impact e.g. diagnostics (due to things // being cfg'ed out). // Ideally we will just expand them to nothing here. But we are only collecting macro calls, // not expanding them, so we have no way to do that. if matches!( def.kind, MacroDefKind::BuiltInAttr(_, expander) if expander.is_test() || expander.is_bench() || expander.is_test_case() ) { let test_is_active = self.cfg_options.check_atom(&CfgAtom::Flag(sym::test)); if test_is_active { return recollect_without(self); } } let mut call_id = || { let active_attrs = self.prev_active_attrs.entry(ast_id).or_default(); active_attrs.push(*attr_id); attr_macro_as_call_id( self.db, file_ast_id, attr, AttrMacroAttrIds::from_many(active_attrs), self.def_map.krate, def, ) }; if matches!(def, MacroDefId { kind: MacroDefKind::BuiltInAttr(_, exp), .. } if exp.is_derive() ) { // Resolved to `#[derive]`, we don't actually expand this attribute like // normal (as that would just be an identity expansion with extra output) // Instead we treat derive attributes special and apply them separately. let ast_adt_id: FileAstId = match *mod_item { ModItemId::Struct(ast_id) => ast_id.upcast(), ModItemId::Union(ast_id) => ast_id.upcast(), ModItemId::Enum(ast_id) => ast_id.upcast(), _ => { let diag = DefDiagnostic::invalid_derive_target( directive.module_id, ast_id, *attr_id, ); self.def_map.diagnostics.push(diag); return recollect_without(self); } }; let ast_id = ast_id.with_value(ast_adt_id); let mut derive_call_ids = SmallVec::new(); match attr.parse_path_comma_token_tree(self.db) { Some(derive_macros) => { let call_id = call_id(); for (idx, (path, call_site, _)) in derive_macros.enumerate() { let ast_id = AstIdWithPath::new( file_id, ast_id.value, Interned::new(path), ); derive_call_ids.push(None); // Try to resolve the derive immediately. If we succeed, we can also use the fast path // for builtin derives. If not, we cannot use it, as it can cause the ADT to become // interned while the derive is still unresolved, which will cause it to get forgotten. let id = derive_macro_as_call_id( self.db, &ast_id, *attr_id, idx as u32, call_site.ctx, self.def_map.krate, |path| resolver(&self.def_map, path), call_id, ); let ast_id_without_path = ast_id.ast_id; let directive = MacroDirective { module_id: directive.module_id, depth: directive.depth + 1, kind: MacroDirectiveKind::Derive { ast_id, derive_attr: *attr_id, derive_pos: idx, ctxt: call_site.ctx, derive_macro_id: call_id, }, container: directive.container, }; if let Ok((macro_id, def_id, call_id)) = id { let (mut helpers_start, mut helpers_end) = (0, 0); // Record its helper attributes. if def_id.krate != self.def_map.krate { let def_map = crate_def_map(self.db, def_id.krate); if let Some(helpers) = def_map.data.exported_derives.get(¯o_id) { let derive_helpers = self .def_map .derive_helpers_in_scope .entry( ast_id_without_path.map(|it| it.upcast()), ) .or_default(); helpers_start = derive_helpers.len(); derive_helpers.extend(izip!( helpers.iter().cloned(), iter::repeat(macro_id), iter::repeat(Either::Left(call_id)), )); helpers_end = derive_helpers.len(); } } if super::enable_builtin_derive_fast_path() && let MacroDefKind::BuiltInDerive(_, builtin_derive) = def_id.kind { self.deferred_builtin_derives .entry(ast_id_without_path.upcast()) .or_default() .push(DeferredBuiltinDerive { call_id, derive: builtin_derive, module_id: directive.module_id, container: directive.container, depth: directive.depth, derive_attr_id: *attr_id, derive_index: idx as u32, helpers_range: helpers_start..helpers_end, }); } else { push_resolved(&mut resolved, &directive, call_id); *derive_call_ids.last_mut().unwrap() = Some(Either::Left(call_id)); } } else { self.unresolved_macros.push(directive); } } // We treat the #[derive] macro as an attribute call, but we do not resolve it for nameres collection. // This is just a trick to be able to resolve the input to derives // as proper paths in `Semantics`. // Check the comment in [`builtin_attr_macro`]. self.def_map.modules[directive.module_id] .scope .init_derive_attribute( ast_id, *attr_id, call_id, derive_call_ids, ); } None => { let diag = DefDiagnostic::malformed_derive( directive.module_id, ast_id, *attr_id, ); self.def_map.diagnostics.push(diag); } } return recollect_without(self); } if let MacroDefKind::ProcMacro(_, exp, _) = def.kind { // If there's no expander for the proc macro (e.g. // because proc macros are disabled, or building the // proc macro crate failed), report this and skip // expansion like we would if it was disabled if let Some(err) = exp.as_expand_error(def.krate) { self.def_map.diagnostics.push(DefDiagnostic::macro_error( directive.module_id, ast_id, (**path).clone(), err, )); return recollect_without(self); } } // Clear deferred derives for this item, unfortunately we cannot use them due to the attribute. if let Some(deferred_derives) = self.deferred_builtin_derives.remove(&ast_id) { resolved.extend(deferred_derives.into_iter().map(|derive| { ( derive.module_id, derive.depth, derive.container, derive.call_id, Some(ast_id), ) })); } let call_id = call_id(); self.def_map.modules[directive.module_id] .scope .add_attr_macro_invoc(ast_id, call_id); push_resolved(&mut resolved, directive, call_id); res = ReachedFixedPoint::No; return Resolved::Yes; } } Resolved::No }; macros.retain(|it| retain(it) == Resolved::No); // Attribute resolution can add unresolved macro invocations, so concatenate the lists. macros.extend(mem::take(&mut self.unresolved_macros)); self.unresolved_macros = macros; for (module_id, ptr, call_id) in eager_callback_buffer { self.def_map.modules[module_id].scope.add_macro_invoc(ptr.map(|(_, it)| it), call_id); } for (module_id, depth, container, macro_call_id, attr_macro_item) in resolved { self.collect_macro_expansion( module_id, macro_call_id, depth, container, attr_macro_item, ); } res } fn collect_macro_expansion( &mut self, module_id: ModuleId, macro_call_id: MacroCallId, depth: usize, container: ItemContainerId, attr_macro_item: Option>, ) { if depth > self.def_map.recursion_limit() as usize { cov_mark::hit!(macro_expansion_overflow); tracing::warn!("macro expansion is too deep"); return; } let file_id = macro_call_id.into(); let item_tree = self.db.file_item_tree(file_id); // Derive helpers that are in scope for an item are also in scope for attribute macro expansions // of that item (but not derive or fn like macros). // FIXME: This is a hack. The proper way to do this is by having a chain of derive helpers scope, // where the next scope in the chain is the parent hygiene context of the span. Unfortunately // it's difficult to implement with our current name resolution and hygiene system. // This hack is also incorrect since it ignores item in blocks. But the main reason to bring derive // helpers into scope in this case is to help with: // ``` // #[derive(DeriveWithHelper)] // #[helper] // #[attr_macro] // struct Foo; // ``` // Where `attr_macro`'s input will include `#[helper]` but not the derive, and it will likely therefore // also include it in its output. Therefore I hope not supporting blocks is fine at least for now. if let Some(attr_macro_item) = attr_macro_item && let Some(derive_helpers) = self.def_map.derive_helpers_in_scope.get(&attr_macro_item) { let derive_helpers = derive_helpers.clone(); for item in item_tree.top_level_items() { self.def_map .derive_helpers_in_scope .entry(InFile::new(file_id, item.ast_id())) .or_default() .extend(derive_helpers.iter().cloned()); } } let mod_dir = if macro_call_id.is_include_macro(self.db) { ModDir::root() } else { self.mod_dirs[&module_id].clone() }; ModCollector { def_collector: &mut *self, macro_depth: depth, tree_id: TreeId::new(file_id, None), module_id, item_tree, mod_dir, } .collect(item_tree.top_level_items(), container); } fn finish(mut self) -> (DefMap, LocalDefMap) { // Emit diagnostics for all remaining unexpanded macros. let _p = tracing::info_span!("DefCollector::finish").entered(); for directive in &self.unresolved_macros { match &directive.kind { MacroDirectiveKind::FnLike { ast_id, expand_to, ctxt: call_site } => { // FIXME: we shouldn't need to re-resolve the macro here just to get the unresolved error! let macro_call_as_call_id = macro_call_as_call_id( self.db, ast_id.ast_id, &ast_id.path, *call_site, *expand_to, self.def_map.krate, |path| { let resolved_res = self.def_map.resolve_path_fp_with_macro( self.crate_local_def_map.unwrap_or(&self.local_def_map), self.db, ResolveMode::Other, directive.module_id, path, BuiltinShadowMode::Module, Some(MacroSubNs::Bang), ); resolved_res.resolved_def.take_macros().map(|it| self.db.macro_def(it)) }, &mut |_, _| (), ); if let Err(UnresolvedMacro { path }) = macro_call_as_call_id { self.def_map.diagnostics.push(DefDiagnostic::unresolved_macro_call( directive.module_id, MacroCallKind::FnLike { ast_id: ast_id.ast_id, expand_to: *expand_to, eager: None, }, path, )); } } MacroDirectiveKind::Derive { ast_id, derive_attr, derive_pos, derive_macro_id, .. } => { self.def_map.diagnostics.push(DefDiagnostic::unresolved_macro_call( directive.module_id, MacroCallKind::Derive { ast_id: ast_id.ast_id, derive_attr_index: *derive_attr, derive_index: *derive_pos as u32, derive_macro_id: *derive_macro_id, }, (*ast_id.path).clone(), )); } // These are diagnosed by `reseed_with_unresolved_attribute`, as that function consumes them MacroDirectiveKind::Attr { .. } => {} } } // Emit diagnostics for all remaining unresolved imports. for import in &self.unresolved_imports { let &ImportDirective { module_id, import: Import { ref path, source: ImportSource { use_tree, id, is_prelude: _, kind: _ }, .. }, .. } = import; if matches!( (path.segments().first(), &path.kind), (Some(krate), PathKind::Plain | PathKind::Abs) if self.unresolved_extern_crates.contains(krate) ) { continue; } let item_tree_id = id.lookup(self.db).id; self.def_map.diagnostics.push(DefDiagnostic::unresolved_import( module_id, item_tree_id, use_tree, )); } always!( self.deferred_builtin_derives.is_empty(), "self.deferred_builtin_derives={:#?}", self.deferred_builtin_derives, ); (self.def_map, self.local_def_map) } } /// Walks a single module, populating defs, imports and macros struct ModCollector<'a, 'db> { def_collector: &'a mut DefCollector<'db>, macro_depth: usize, module_id: ModuleId, tree_id: TreeId, item_tree: &'db ItemTree, mod_dir: ModDir, } impl ModCollector<'_, '_> { fn collect_in_top_module(&mut self, items: &[ModItemId]) { self.collect(items, self.module_id.into()) } fn collect(&mut self, items: &[ModItemId], container: ItemContainerId) { let krate = self.def_collector.def_map.krate; let is_crate_root = self.module_id == self.def_collector.def_map.root && self.def_collector.def_map.block.is_none(); // Note: don't assert that inserted value is fresh: it's simply not true // for macros. self.def_collector.mod_dirs.insert(self.module_id, self.mod_dir.clone()); // Prelude module is always considered to be `#[macro_use]`. if let Some((prelude_module, _use)) = self.def_collector.def_map.prelude { // Don't insert macros from the prelude into blocks, as they can be shadowed by other macros. if is_crate_root && prelude_module.krate(self.def_collector.db) != krate { cov_mark::hit!(prelude_is_macro_use); self.def_collector.import_macros_from_extern_crate( prelude_module.krate(self.def_collector.db), None, None, ); } } let db = self.def_collector.db; let module_id = self.module_id; let consider_deferred_derives = |file_id: HirFileId, deferred_derives: &mut FxHashMap<_, Vec>, ast_id: FileAstId, id: AdtId, def_map: &mut DefMap| { let ast_id = InFile::new(file_id, ast_id.upcast()); let Some(deferred_derives) = deferred_derives.remove(&ast_id.upcast()) else { return; }; let module = &mut def_map.modules[module_id]; for deferred_derive in deferred_derives { crate::builtin_derive::with_derive_traits(deferred_derive.derive, |trait_| { let impl_id = BuiltinDeriveImplId::new( db, BuiltinDeriveImplLoc { adt: id, trait_, derive_attr_id: deferred_derive.derive_attr_id, derive_index: deferred_derive.derive_index, }, ); module.scope.define_builtin_derive_impl(impl_id); module.scope.set_derive_macro_invoc( ast_id, Either::Right(impl_id), deferred_derive.derive_attr_id, deferred_derive.derive_index as usize, ); // Change its helper attributes to the new id. if let Some(derive_helpers) = def_map.derive_helpers_in_scope.get_mut(&ast_id.map(|it| it.upcast())) { for (_, _, call_id) in &mut derive_helpers[deferred_derive.helpers_range.clone()] { *call_id = Either::Right(impl_id); } } }); } }; let update_def = |def_collector: &mut DefCollector<'_>, id, name: &Name, vis, has_constructor| { def_collector.def_map.modules[module_id].scope.declare(id); def_collector.update( module_id, &[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor, None))], vis, None, ) }; let resolve_vis = |def_map: &DefMap, local_def_map: &LocalDefMap, visibility| { def_map .resolve_visibility(local_def_map, db, module_id, visibility, false) .unwrap_or(Visibility::Public) }; let mut process_mod_item = |item: ModItemId| { let attrs = match self.item_tree.attrs(item.ast_id()) { Some(AttrsOrCfg::Enabled { attrs }) => attrs.as_ref(), None => Attrs::EMPTY, Some(AttrsOrCfg::CfgDisabled(cfg)) => { let ast_id = item.ast_id().erase(); self.emit_unconfigured_diagnostic(InFile::new(self.file_id(), ast_id), &cfg.0); return; } }; if let Err(()) = self.resolve_attributes(attrs, item, container) { // Do not process the item. It has at least one non-builtin attribute, so the // fixed-point algorithm is required to resolve the rest of them. return; } let def_map = &mut self.def_collector.def_map; let local_def_map = self.def_collector.crate_local_def_map.unwrap_or(&self.def_collector.local_def_map); match item { ModItemId::Mod(m) => self.collect_module(m, attrs), ModItemId::Use(item_tree_id) => { let id = UseLoc { container: module_id, id: InFile::new(self.file_id(), item_tree_id), } .intern(db); let is_prelude = attrs.by_key(sym::prelude_import).exists(); Import::from_use(self.item_tree, item_tree_id, id, is_prelude, |import| { self.def_collector.unresolved_imports.push(ImportDirective { module_id: self.module_id, import, status: PartialResolvedImport::Unresolved, }); }) } ModItemId::ExternCrate(item_tree_id) => { let item_tree::ExternCrate { name, visibility, alias } = &self.item_tree[item_tree_id]; let id = ExternCrateLoc { container: module_id, id: InFile::new(self.tree_id.file_id(), item_tree_id), } .intern(db); def_map.modules[self.module_id].scope.define_extern_crate_decl(id); let is_self = *name == sym::self_; let resolved = if is_self { cov_mark::hit!(extern_crate_self_as); Some(def_map.crate_root(db)) } else { self.def_collector .deps .get(name) .map(|dep| crate_def_map(db, dep.crate_id).root_module_id()) }; let name = match alias { Some(ImportAlias::Alias(name)) => Some(name), Some(ImportAlias::Underscore) => None, None => Some(name), }; if let Some(resolved) = resolved { let vis = resolve_vis(def_map, local_def_map, &self.item_tree[*visibility]); if is_crate_root { // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658 if let Some(name) = name { self.def_collector .local_def_map .extern_prelude .insert(name.clone(), (resolved, Some(id))); } // they also allow `#[macro_use]` if !is_self { self.process_macro_use_extern_crate( id, attrs.by_key(sym::macro_use).attrs(), resolved.krate(self.def_collector.db), ); } } self.def_collector.update( module_id, &[( name.cloned(), PerNs::types( resolved.into(), vis, Some(ImportOrExternCrate::ExternCrate(id)), ), )], vis, Some(ImportOrExternCrate::ExternCrate(id)), ); } else { if let Some(name) = name { self.def_collector.unresolved_extern_crates.insert(name.clone()); } self.def_collector.def_map.diagnostics.push( DefDiagnostic::unresolved_extern_crate( module_id, InFile::new(self.file_id(), item_tree_id), ), ); } } ModItemId::ExternBlock(block) => { let extern_block_id = ExternBlockLoc { container: module_id, id: InFile::new(self.file_id(), block), } .intern(db); self.def_collector.def_map.modules[self.module_id] .scope .define_extern_block(extern_block_id); self.collect( &self.item_tree[block].children, ItemContainerId::ExternBlockId(extern_block_id), ) } ModItemId::MacroCall(mac) => self.collect_macro_call(mac, container), ModItemId::MacroRules(id) => self.collect_macro_rules(id, module_id), ModItemId::Macro2(id) => self.collect_macro_def(id, module_id), ModItemId::Impl(imp) => { let impl_id = ImplLoc { container: module_id, id: InFile::new(self.file_id(), imp) } .intern(db); self.def_collector.def_map.modules[self.module_id] .scope .define_impl(impl_id, self.item_tree[imp].is_trait_impl) } ModItemId::Function(id) => { let it = &self.item_tree[id]; let fn_id = FunctionLoc { container, id: InFile::new(self.tree_id.file_id(), id) } .intern(db); let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]); update_def(self.def_collector, fn_id.into(), &it.name, vis, false); if self.def_collector.def_map.block.is_none() && self.def_collector.is_proc_macro && self.module_id == self.def_collector.def_map.root && let Some(proc_macro) = attrs.parse_proc_macro_decl(&it.name) { self.def_collector.export_proc_macro( proc_macro, InFile::new(self.file_id(), id), fn_id, ); // A proc macro is implemented as a function, but it's treated as a macro, not a function. // You cannot call it like a function, for example, except in its defining crate. // So we keep the function definition, but remove it from the scope, leaving only the macro. self.def_collector.def_map[module_id] .scope .remove_from_value_ns(&it.name, fn_id.into()); } } ModItemId::Struct(id) => { let it = &self.item_tree[id]; let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]); let interned = StructLoc { container: module_id, id: InFile::new(self.tree_id.file_id(), id), } .intern(db); consider_deferred_derives( self.tree_id.file_id(), &mut self.def_collector.deferred_builtin_derives, id.upcast(), interned.into(), def_map, ); update_def( self.def_collector, interned.into(), &it.name, vis, !matches!(it.shape, FieldsShape::Record), ); } ModItemId::Union(id) => { let it = &self.item_tree[id]; let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]); let interned = UnionLoc { container: module_id, id: InFile::new(self.tree_id.file_id(), id), } .intern(db); consider_deferred_derives( self.tree_id.file_id(), &mut self.def_collector.deferred_builtin_derives, id.upcast(), interned.into(), def_map, ); update_def(self.def_collector, interned.into(), &it.name, vis, false); } ModItemId::Enum(id) => { let it = &self.item_tree[id]; let enum_ = EnumLoc { container: module_id, id: InFile::new(self.tree_id.file_id(), id), } .intern(db); consider_deferred_derives( self.tree_id.file_id(), &mut self.def_collector.deferred_builtin_derives, id.upcast(), enum_.into(), def_map, ); let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]); update_def(self.def_collector, enum_.into(), &it.name, vis, false); } ModItemId::Const(id) => { let it = &self.item_tree[id]; let const_id = ConstLoc { container, id: InFile::new(self.tree_id.file_id(), id) } .intern(db); match &it.name { Some(name) => { let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]); update_def(self.def_collector, const_id.into(), name, vis, false); } None => { // const _: T = ...; self.def_collector.def_map.modules[self.module_id] .scope .define_unnamed_const(const_id); } } } ModItemId::Static(id) => { let it = &self.item_tree[id]; let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]); update_def( self.def_collector, StaticLoc { container, id: InFile::new(self.file_id(), id) } .intern(db) .into(), &it.name, vis, false, ); } ModItemId::Trait(id) => { let it = &self.item_tree[id]; let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]); update_def( self.def_collector, TraitLoc { container: module_id, id: InFile::new(self.file_id(), id) } .intern(db) .into(), &it.name, vis, false, ); } ModItemId::TypeAlias(id) => { let it = &self.item_tree[id]; let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]); update_def( self.def_collector, TypeAliasLoc { container, id: InFile::new(self.file_id(), id) } .intern(db) .into(), &it.name, vis, false, ); } } }; // extern crates should be processed eagerly instead of deferred to resolving. // `#[macro_use] extern crate` is hoisted to imports macros before collecting // any other items. if is_crate_root { items .iter() .filter(|it| matches!(it, ModItemId::ExternCrate(..))) .copied() .for_each(&mut process_mod_item); items .iter() .filter(|it| !matches!(it, ModItemId::ExternCrate(..))) .copied() .for_each(process_mod_item); } else { items.iter().copied().for_each(process_mod_item); } } fn process_macro_use_extern_crate<'a>( &mut self, extern_crate_id: ExternCrateId, macro_use_attrs: impl Iterator, target_crate: Crate, ) { cov_mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use); let mut single_imports = Vec::new(); for attr in macro_use_attrs { let Some(paths) = attr.parse_path_comma_token_tree(self.def_collector.db) else { // `#[macro_use]` (without any paths) found, forget collected names and just import // all visible macros. self.def_collector.import_macros_from_extern_crate( target_crate, None, Some(extern_crate_id), ); return; }; for (path, _, _) in paths { if let Some(name) = path.as_ident() { single_imports.push(name.clone()); } } } self.def_collector.import_macros_from_extern_crate( target_crate, Some(single_imports), Some(extern_crate_id), ); } fn collect_module(&mut self, module_ast_id: ItemTreeAstId, attrs: Attrs<'_>) { let path_attr = attrs.by_key(sym::path).string_value_unescape(); let is_macro_use = attrs.by_key(sym::macro_use).exists(); let module = &self.item_tree[module_ast_id]; match &module.kind { // inline module, just recurse ModKind::Inline { items } => { let module_id = self.push_child_module( module.name.clone(), module_ast_id, None, &self.item_tree[module.visibility], ); let Some(mod_dir) = self.mod_dir.descend_into_definition(&module.name, path_attr.as_deref()) else { return; }; ModCollector { def_collector: &mut *self.def_collector, macro_depth: self.macro_depth, module_id, tree_id: self.tree_id, item_tree: self.item_tree, mod_dir, } .collect_in_top_module(items); if is_macro_use { self.import_all_legacy_macros(module_id); } } // out of line module, resolve, parse and recurse ModKind::Outline => { let ast_id = AstId::new(self.file_id(), module_ast_id); let db = self.def_collector.db; match self.mod_dir.resolve_declaration( db, self.file_id(), &module.name, path_attr.as_deref(), self.def_collector.def_map.krate, ) { Ok((file_id, is_mod_rs, mod_dir)) => { let item_tree = db.file_item_tree(file_id.into()); match item_tree.top_level_attrs() { AttrsOrCfg::CfgDisabled(cfg) => { self.emit_unconfigured_diagnostic( InFile::new(self.file_id(), module_ast_id.erase()), &cfg.0, ); } AttrsOrCfg::Enabled { attrs } => { let module_id = self.push_child_module( module.name.clone(), ast_id.value, Some((file_id, is_mod_rs)), &self.item_tree[module.visibility], ); ModCollector { def_collector: self.def_collector, macro_depth: self.macro_depth, module_id, tree_id: TreeId::new(file_id.into(), None), item_tree, mod_dir, } .collect_in_top_module(item_tree.top_level_items()); let is_macro_use = is_macro_use || attrs.as_ref().by_key(sym::macro_use).exists(); if is_macro_use { self.import_all_legacy_macros(module_id); } } } } Err(candidates) => { self.push_child_module( module.name.clone(), ast_id.value, None, &self.item_tree[module.visibility], ); self.def_collector.def_map.diagnostics.push( DefDiagnostic::unresolved_module(self.module_id, ast_id, candidates), ); } }; } } } fn push_child_module( &mut self, name: Name, declaration: FileAstId, definition: Option<(EditionedFileId, bool)>, visibility: &crate::visibility::RawVisibility, ) -> ModuleId { let vis = self .def_collector .def_map .resolve_visibility( self.def_collector.crate_local_def_map.unwrap_or(&self.def_collector.local_def_map), self.def_collector.db, self.module_id, visibility, false, ) .unwrap_or(Visibility::Public); let origin = match definition { None => { ModuleOrigin::Inline { definition: declaration, definition_tree_id: self.tree_id } } Some((definition, is_mod_rs)) => ModuleOrigin::File { declaration, definition, is_mod_rs, declaration_tree_id: self.tree_id, }, }; let module = unsafe { crate::ModuleIdLt::new( self.def_collector.db, self.def_collector.def_map.krate, self.def_collector.def_map.block_id(), ) .to_static() }; let def_map = &mut self.def_collector.def_map; let modules = &mut def_map.modules; let mut data = ModuleData::new(origin, vis, Some(self.module_id)); for (name, macs) in modules[self.module_id].scope.legacy_macros() { for &mac in macs { data.scope.define_legacy_macro(name.clone(), mac); } } modules[self.module_id].children.insert(name.clone(), module); modules.insert(module, data); let def = ModuleDefId::from(module); def_map.modules[self.module_id].scope.declare(def); self.def_collector.update( self.module_id, &[(Some(name), PerNs::from_def(def, vis, false, None))], vis, None, ); module } /// Resolves attributes on an item. /// /// Returns `Err` when some attributes could not be resolved to builtins and have been /// registered as unresolved. /// /// If `ignore_up_to` is `Some`, attributes preceding and including that attribute will be /// assumed to be resolved already. fn resolve_attributes( &mut self, attrs: Attrs<'_>, mod_item: ModItemId, container: ItemContainerId, ) -> Result<(), ()> { let ignore_up_to = self .def_collector .skip_attrs .get(&InFile::new(self.file_id(), mod_item.ast_id())) .copied(); for (attr_id, attr) in attrs.iter_after(ignore_up_to) { if self.def_collector.def_map.is_builtin_or_registered_attr(&attr.path) { continue; } tracing::debug!( "non-builtin attribute {}", attr.path.display(self.def_collector.db, Edition::LATEST) ); let ast_id = AstIdWithPath::new(self.file_id(), mod_item.ast_id(), attr.path.clone()); self.def_collector.unresolved_macros.push(MacroDirective { module_id: self.module_id, depth: self.macro_depth + 1, kind: MacroDirectiveKind::Attr { ast_id, attr_id, attr: attr.clone(), mod_item, tree: self.tree_id, item_tree: self.item_tree, }, container, }); return Err(()); } Ok(()) } fn collect_macro_rules(&mut self, ast_id: ItemTreeAstId, module: ModuleId) { let krate = self.def_collector.def_map.krate; let mac = &self.item_tree[ast_id]; let attrs = match self.item_tree.attrs(ast_id.upcast()) { Some(AttrsOrCfg::Enabled { attrs }) => attrs.as_ref(), None => Attrs::EMPTY, Some(AttrsOrCfg::CfgDisabled(_)) => { unreachable!("we only get here if the macro is not cfg'ed out") } }; let f_ast_id = InFile::new(self.file_id(), ast_id.upcast()); let export_attr = || attrs.by_key(sym::macro_export); let is_export = export_attr().exists(); let local_inner = if is_export { export_attr().tt_values().flat_map(|it| it.iter()).any(|it| match it { tt::TtElement::Leaf(tt::Leaf::Ident(ident)) => ident.sym == sym::local_inner_macros, _ => false, }) } else { false }; // Case 1: builtin macros let expander = if attrs.by_key(sym::rustc_builtin_macro).exists() { // `#[rustc_builtin_macro = "builtin_name"]` overrides the `macro_rules!` name. let name; let name = match attrs.by_key(sym::rustc_builtin_macro).string_value_with_span() { Some((it, span)) => { name = Name::new_symbol(Symbol::intern(it), span.ctx); &name } None => { let explicit_name = attrs.by_key(sym::rustc_builtin_macro).tt_values().next().and_then(|tt| { match tt.token_trees().iter().next() { Some(tt::TtElement::Leaf(tt::Leaf::Ident(name))) => Some(name), _ => None, } }); match explicit_name { Some(ident) => { name = ident.as_name(); &name } None => &mac.name, } } }; match find_builtin_macro(name) { Some(Either::Left(it)) => MacroExpander::BuiltIn(it), Some(Either::Right(it)) => MacroExpander::BuiltInEager(it), None => { self.def_collector .def_map .diagnostics .push(DefDiagnostic::unimplemented_builtin_macro(self.module_id, f_ast_id)); return; } } } else { // Case 2: normal `macro_rules!` macro let id = InFile::new(self.file_id(), ast_id); let decl_expander = self.def_collector.db.decl_macro_expander(krate, id.upcast()); let styles = decl_expander.mac.rule_styles(); MacroExpander::Declarative { styles } }; let allow_internal_unsafe = attrs.by_key(sym::allow_internal_unsafe).exists(); let mut flags = MacroRulesLocFlags::empty(); flags.set(MacroRulesLocFlags::LOCAL_INNER, local_inner); flags.set(MacroRulesLocFlags::ALLOW_INTERNAL_UNSAFE, allow_internal_unsafe); let macro_id = MacroRulesLoc { container: module, id: InFile::new(self.file_id(), ast_id), flags, expander, edition: self.def_collector.def_map.data.edition, } .intern(self.def_collector.db); self.def_collector.def_map.macro_def_to_macro_id.insert(f_ast_id.erase(), macro_id.into()); self.def_collector.define_macro_rules( self.module_id, mac.name.clone(), macro_id, is_export, ); } fn collect_macro_def(&mut self, ast_id: ItemTreeAstId, module: ModuleId) { let krate = self.def_collector.def_map.krate; let mac = &self.item_tree[ast_id]; let attrs = match self.item_tree.attrs(ast_id.upcast()) { Some(AttrsOrCfg::Enabled { attrs }) => attrs.as_ref(), None => Attrs::EMPTY, Some(AttrsOrCfg::CfgDisabled(_)) => { unreachable!("we only get here if the macro is not cfg'ed out") } }; let f_ast_id = InFile::new(self.file_id(), ast_id.upcast()); // Case 1: builtin macros let mut helpers_opt = None; let expander = if attrs.by_key(sym::rustc_builtin_macro).exists() { if let Some(expander) = find_builtin_macro(&mac.name) { match expander { Either::Left(it) => MacroExpander::BuiltIn(it), Either::Right(it) => MacroExpander::BuiltInEager(it), } } else if let Some(expander) = find_builtin_derive(&mac.name) { if let Some(attr) = attrs.by_key(sym::rustc_builtin_macro).tt_values().next() { // NOTE: The item *may* have both `#[rustc_builtin_macro]` and `#[proc_macro_derive]`, // in which case rustc ignores the helper attributes from the latter, but it // "doesn't make sense in practice" (see rust-lang/rust#87027). if let Some((name, helpers)) = parse_macro_name_and_helper_attrs(attr) { // NOTE: rustc overrides the name if the macro name if it's different from the // macro name, but we assume it isn't as there's no such case yet. FIXME if // the following assertion fails. stdx::always!( name == mac.name, "built-in macro {} has #[rustc_builtin_macro] which declares different name {}", mac.name.display(self.def_collector.db, Edition::LATEST), name.display(self.def_collector.db, Edition::LATEST), ); helpers_opt = Some(helpers); } } MacroExpander::BuiltInDerive(expander) } else if let Some(expander) = find_builtin_attr(&mac.name) { MacroExpander::BuiltInAttr(expander) } else { self.def_collector .def_map .diagnostics .push(DefDiagnostic::unimplemented_builtin_macro(self.module_id, f_ast_id)); return; } } else { // Case 2: normal `macro` let id = InFile::new(self.file_id(), ast_id); let decl_expander = self.def_collector.db.decl_macro_expander(krate, id.upcast()); let styles = decl_expander.mac.rule_styles(); MacroExpander::Declarative { styles } }; let allow_internal_unsafe = attrs.by_key(sym::allow_internal_unsafe).exists(); let macro_id = Macro2Loc { container: module, id: InFile::new(self.file_id(), ast_id), expander, allow_internal_unsafe, edition: self.def_collector.def_map.data.edition, } .intern(self.def_collector.db); self.def_collector.def_map.macro_def_to_macro_id.insert(f_ast_id.erase(), macro_id.into()); self.def_collector.define_macro_def( self.module_id, mac.name.clone(), macro_id, &self.item_tree[mac.visibility], ); if let Some(helpers) = helpers_opt && self.def_collector.def_map.block.is_none() { Arc::get_mut(&mut self.def_collector.def_map.data) .unwrap() .exported_derives .insert(macro_id.into(), helpers); } } fn collect_macro_call( &mut self, ast_id: FileAstId, container: ItemContainerId, ) { let &MacroCall { ref path, expand_to, ctxt } = &self.item_tree[ast_id]; let ast_id = AstIdWithPath::new(self.file_id(), ast_id, path.clone()); let db = self.def_collector.db; // FIXME: Immediately expanding in "Case 1" is insufficient since "Case 2" may also define // new legacy macros that create textual scopes. We need a way to resolve names in textual // scopes without eager expansion. let mut eager_callback_buffer = vec![]; // Case 1: try to resolve macro calls with single-segment name and expand macro_rules if let Ok(res) = macro_call_as_call_id( db, ast_id.ast_id, &ast_id.path, ctxt, expand_to, self.def_collector.def_map.krate, |path| { path.as_ident().and_then(|name| { let def_map = &self.def_collector.def_map; def_map .with_ancestor_maps(db, self.module_id, &mut |map, module| { map[module].scope.get_legacy_macro(name)?.last().copied() }) .or_else(|| def_map[self.module_id].scope.get(name).take_macros()) .or_else(|| Some(def_map.macro_use_prelude.get(name).copied()?.0)) .filter(|&id| sub_namespace_match(db, id, Some(MacroSubNs::Bang))) .map(|it| self.def_collector.db.macro_def(it)) }) }, &mut |ptr, call_id| eager_callback_buffer.push((ptr, call_id)), ) { for (ptr, call_id) in eager_callback_buffer { self.def_collector.def_map.modules[self.module_id] .scope .add_macro_invoc(ptr.map(|(_, it)| it), call_id); } // FIXME: if there were errors, this might've been in the eager expansion from an // unresolved macro, so we need to push this into late macro resolution. see fixme above if res.err.is_none() { // Legacy macros need to be expanded immediately, so that any macros they produce // are in scope. if let Some(call_id) = res.value { self.def_collector.def_map.modules[self.module_id] .scope .add_macro_invoc(ast_id.ast_id, call_id); self.def_collector.collect_macro_expansion( self.module_id, call_id, self.macro_depth + 1, container, None, ); } return; } } // Case 2: resolve in module scope, expand during name resolution. self.def_collector.unresolved_macros.push(MacroDirective { module_id: self.module_id, depth: self.macro_depth + 1, kind: MacroDirectiveKind::FnLike { ast_id, expand_to, ctxt }, container, }); } fn import_all_legacy_macros(&mut self, module_id: ModuleId) { let [Some(source), Some(target)] = self.def_collector.def_map.modules.get_disjoint_mut([&module_id, &self.module_id]) else { return; }; for (name, macs) in source.scope.legacy_macros() { if let Some(&mac) = macs.last() { target.scope.define_legacy_macro(name.clone(), mac); } } } fn emit_unconfigured_diagnostic(&mut self, ast_id: ErasedAstId, cfg: &CfgExpr) { self.def_collector.def_map.diagnostics.push(DefDiagnostic::unconfigured_code( self.module_id, ast_id, cfg.clone(), self.def_collector.cfg_options.clone(), )); } #[inline] fn file_id(&self) -> HirFileId { self.tree_id.file_id() } } #[cfg(test)] mod tests { use test_fixture::WithFixture; use crate::test_db::TestDB; use super::*; fn do_resolve(not_ra_fixture: &str) { let (db, _) = TestDB::with_single_file(not_ra_fixture); let krate = db.test_crate(); crate_def_map(&db, krate); } #[test] fn test_macro_expand_will_stop_1() { do_resolve( r#" macro_rules! foo { ($($ty:ty)*) => { foo!($($ty)*); } } foo!(KABOOM); "#, ); do_resolve( r#" macro_rules! foo { ($($ty:ty)*) => { foo!(() $($ty)*); } } foo!(KABOOM); "#, ); } #[ignore] #[test] fn test_macro_expand_will_stop_2() { // FIXME: this test does succeed, but takes quite a while: 90 seconds in // the release mode. That's why the argument is not an ra_fixture -- // otherwise injection highlighting gets stuck. // // We need to find a way to fail this faster! do_resolve( r#" macro_rules! foo { ($($ty:ty)*) => { foo!($($ty)* $($ty)*); } } foo!(KABOOM); "#, ); } #[test] fn crate_attrs() { let fixture = r#" //- /lib.rs crate:foo crate-attr:recursion_limit="4" crate-attr:no_core crate-attr:no_std crate-attr:feature(register_tool) "#; let (db, file_id) = TestDB::with_single_file(fixture); let def_map = crate_def_map(&db, file_id.krate(&db)); assert_eq!(def_map.recursion_limit(), 4); assert!(def_map.is_no_core()); assert!(def_map.is_no_std()); assert!(def_map.is_unstable_feature_enabled(&sym::register_tool)); } }