use std::{cmp::Ordering, iter, mem, ops::Not};

use cfg::{CfgAtom, CfgExpr, CfgOptions};

use either::Either;

use hir_expand::{

attrs::{Attr, AttrId},

builtin::{find_builtin_attr, find_builtin_derive, find_builtin_macro},

name::{AsName, Name},

proc_macro::CustomProcMacroExpander,

};

use la_arena::Idx;

use rustc_hash::{FxHashMap, FxHashSet};

use syntax::ast;

use triomphe::Arc;

use crate::{

attr::Attrs,

db::DefDatabase,

item_scope::{GlobId, ImportId, ImportOrExternCrate, PerNsGlobImports},

item_tree::{

},

macro_call_as_call_id, macro_call_as_call_id_with_eager,

nameres::{

attr_resolution::{attr_macro_as_call_id, derive_macro_as_call_id},

diagnostics::DefDiagnostic,

mod_resolution::ModDir,

path_resolution::ReachedFixedPoint,

},

per_ns::{Item, PerNs},

tt,

visibility::{RawVisibility, Visibility},

};

const GLOB_RECURSION_LIMIT: usize = 100;

const FIXED_POINT_LIMIT: usize = 8192;

// populate external prelude and dependency list

let mut deps =

}

let proc_macros = if krate.is_proc_macro {

.unwrap_or_default()

} else {

Default::default()

let mut collector = DefCollector {

db,

def_map,

deps,

glob_imports: FxHashMap::default(),

unresolved_imports: Vec::new(),

indeterminate_imports: Vec::new(),

unresolved_macros: Vec::new(),

mod_dirs: FxHashMap::default(),

proc_macros,

from_glob_import: Default::default(),

skip_attrs: Default::default(),

collector.seed_with_top_level();

}

collector.collect();

def_map.shrink_to_fit();

}

#[derive(Copy, Clone, Debug, Eq, PartialEq)]

FnLike {

ast_id: AstIdWithPath<ast::MacroCall>,

expand_to: ExpandTo,

},

Derive {

ast_id: AstIdWithPath<ast::Adt>,

derive_attr: AttrId,

derive_pos: usize,

/// The "parent" macro it is resolved to.

derive_macro_id: MacroCallId,

},

struct DefCollector<'a> {

db: &'a dyn DefDatabase,

def_map: DefMap,

// The dependencies of the current crate, including optional deps like `test`.

glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, Visibility, GlobId)>>,

unresolved_imports: Vec<ImportDirective>,

indeterminate_imports: Vec<(ImportDirective, PerNs)>,

fn seed_with_top_level(&mut self) {

let _p = tracing::info_span!("seed_with_top_level").entered();

let item_tree = self.db.file_item_tree(file_id.into());

let attrs = item_tree.top_level_attrs(self.db, self.def_map.krate);

let crate_data = Arc::get_mut(&mut self.def_map.data).unwrap();

let Some(attr_name) = attr.path.as_ident() else { continue };

match () {

if let Some(limit) = attr.string_value() {

if let Ok(limit) = limit.as_str().parse() {

crate_data.recursion_limit = Some(limit);

}

}

}

if attr.string_value() == Some(&sym::proc_dash_macro) {

self.is_proc_macro = true;

}

}

crate_data.rustc_coherence_is_core = true;

}

crate_data.unstable_features.extend(features);

}

if let Some(ident) = attr.single_ident_value() {

crate_data.registered_attrs.push(ident.sym.clone());

cov_mark::hit!(register_attr);

}

}

if let Some(ident) = attr.single_ident_value() {

crate_data.registered_tools.push(ident.sym.clone());

cov_mark::hit!(register_tool);

// 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

if skip {

continue;

}

.extern_prelude

.insert(name.clone(), (CrateRootModuleId { krate: dep.crate_id }, None));

}

'resolve_attr: loop {

let _p = tracing::info_span!("resolve_macros loop").entered();

'resolve_macros: loop {

{

let _p = tracing::info_span!("resolve_imports loop").entered();

}

let krate = if self.def_map.data.no_std {

} else {

// If `std` does not exist for some reason, fall back to core. This mostly helps

// keep r-a's own tests minimal.

};

let edition = match self.def_map.data.edition {

};

let path_kind = match self.def_map.data.edition {

};

let path = ModPath::from_segments(

path_kind,

);

match per_ns.types {

Some(Item { def: ModuleDefId::ModuleId(m), import, .. }) => {

types => {

tracing::debug!(

"could not resolve prelude path `{}` to module (resolved to {:?})",

types

);

}

}

}

/// Adds a definition of procedural macro `name` to the root module.

///

/// # Notes on procedural macro resolution

&mut self,

def: ProcMacroDef,

id: ItemTreeId<item_tree::Function>,

fn_id: FunctionId,

) {

let kind = def.kind.to_basedb_kind();

edition: self.def_map.data.edition,

}

.intern(self.db);

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 {

) {

let vis = self

.def_map

.unwrap_or(Visibility::Public);

self.def_map.modules[module_id].scope.declare(macro_.into());

self.update(

/// created by `use` in the root module, ignoring the visibility of `use`.

fn import_macros_from_extern_crate(

&mut self,

names: Option<Vec<Name>>,

extern_crate: Option<ExternCrateId>,

) {

}

fn resolve_import(&self, module_id: LocalModuleId, import: &Import) -> PartialResolvedImport {

.entered();

tracing::debug!("resolving import: {:?} ({:?})", import, self.def_map.data.edition);

let res = self.def_map.resolve_path_fp_with_macro(

self.db,

ResolveMode::Import,

module_id,

let mut def = directive.status.namespaces();

let vis = self

.def_map

.unwrap_or(Visibility::Public);

match import.source {

Some(ModuleDefId::AdtId(AdtId::EnumId(e))) => {

cov_mark::hit!(glob_enum);

// glob import from enum => just import all the variants

self.update(

module_id,

&resolutions,

vis: Visibility,

import: Option<ImportOrExternCrate>,

) {

self.update_recursive(module_id, resolutions, vis, import, 0)

}

No,

}

let mut res = ReachedFixedPoint::Yes;

// Retain unresolved macros after this round of resolution.

let mut retain = |directive: &MacroDirective| {

};

let resolver = |path: &_| {

let resolved_res = self.def_map.resolve_path_fp_with_macro(

self.db,

ResolveMode::Other,

directive.module_id,

match &directive.kind {

MacroDirectiveKind::FnLike { ast_id, expand_to, ctxt: call_site } => {

let call_id = macro_call_as_call_id(

ast_id,

*call_site,

*expand_to,

self.def_map.krate,

resolver_def_id,

);

if let Ok(Some(call_id)) = call_id {

self.def_map.modules[directive.module_id]

MacroDefKind::BuiltInAttr(_, expander)

if expander.is_test() || expander.is_bench() || expander.is_test_case()

) {

if test_is_active {

return recollect_without(self);

}

let ast_id = ast_id.with_value(ast_adt_id);

Some(derive_macros) => {

let call_id = call_id();

let mut len = 0;

macros.extend(mem::take(&mut self.unresolved_macros));

self.unresolved_macros = macros;

for (module_id, depth, container, macro_call_id) in resolved {

self.collect_macro_expansion(module_id, macro_call_id, depth, container);

}

tracing::warn!("macro expansion is too deep");

return;

}

let item_tree = self.db.file_item_tree(file_id);

ModDir::root()

} else {

self.mod_dirs[&module_id].clone()

.collect(item_tree.top_level_items(), container);

}

// Emit diagnostics for all remaining unexpanded macros.

let _p = tracing::info_span!("DefCollector::finish").entered();

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(

ast_id,

*call_site,

*expand_to,

self.def_map.krate,

|path| {

let resolved_res = self.def_map.resolve_path_fp_with_macro(

self.db,

ResolveMode::Other,

directive.module_id,

);

resolved_res.resolved_def.take_macros().map(|it| self.db.macro_def(it))

},

);

if let Err(UnresolvedMacro { path }) = macro_call_as_call_id {

self.def_map.diagnostics.push(DefDiagnostic::unresolved_macro_call(

));

}

}

}

None,

)

};

def_map

.unwrap_or(Visibility::Public)

};

let module = self.def_collector.def_map.module_id(module_id);

let def_map = &mut self.def_collector.def_map;

match item {

ModItem::Mod(m) => self.collect_module(m, &attrs),

id: ItemTreeId::new(self.tree_id, item_tree_id),

}

.intern(db);

Import::from_use(

self.item_tree,

ItemTreeId::new(self.tree_id, item_tree_id),

};

if let Some(resolved) = resolved {

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 {

.extern_prelude

.insert(name.clone(), (resolved, Some(id)));

}

if !is_self {

self.process_macro_use_extern_crate(

id,

resolved.krate,

);

}

let fn_id =

FunctionLoc { container, id: ItemTreeId::new(self.tree_id, id) }.intern(db);

if self.def_collector.def_map.block.is_none()

&& self.def_collector.is_proc_macro

self.def_collector.export_proc_macro(

proc_macro,

ItemTreeId::new(self.tree_id, id),

fn_id,

);

}

ModItem::Struct(id) => {

let it = &self.item_tree[id];

update_def(

self.def_collector,

StructLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }

ModItem::Union(id) => {

let it = &self.item_tree[id];

update_def(

self.def_collector,

UnionLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }

EnumLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }

.intern(db);

update_def(self.def_collector, enum_.into(), &it.name, vis, false);

}

ModItem::Const(id) => {

let it = &self.item_tree[id];

match &it.name {

Some(name) => {

update_def(self.def_collector, const_id.into(), name, vis, false);

}

None => {

ModItem::Static(id) => {

let it = &self.item_tree[id];

update_def(

self.def_collector,

StaticLoc { container, id: ItemTreeId::new(self.tree_id, id) }

ModItem::Trait(id) => {

let it = &self.item_tree[id];

update_def(

self.def_collector,

TraitLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }

ModItem::TraitAlias(id) => {

let it = &self.item_tree[id];

update_def(

self.def_collector,

TraitAliasLoc { container: module, id: ItemTreeId::new(self.tree_id, id) }

ModItem::TypeAlias(id) => {

let it = &self.item_tree[id];

update_def(

self.def_collector,

TypeAliasLoc { container, id: ItemTreeId::new(self.tree_id, id) }

&mut self,

extern_crate_id: ExternCrateId,

macro_use_attrs: impl Iterator<Item = &'a Attr>,

) {

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 {

// `#[macro_use]` (without any paths) found, forget collected names and just import

// all visible macros.

self.def_collector.import_macros_from_extern_crate(

}

fn collect_module(&mut self, module_id: FileItemTreeId<Mod>, attrs: &Attrs) {

let module = &self.item_tree[module_id];

match &module.kind {

// inline module, just recurse

let is_macro_use = is_macro_use

|| item_tree

.top_level_attrs(db, krate)

.exists();

if is_macro_use {

self.import_all_legacy_macros(module_id);

) -> LocalModuleId {

let def_map = &mut self.def_collector.def_map;

let vis = def_map

.unwrap_or(Visibility::Public);

let origin = match definition {

None => ModuleOrigin::Inline {

}

tracing::debug!(

"non-builtin attribute {}",

);

let ast_id = AstIdWithPath::new(

let attrs = self.item_tree.attrs(self.def_collector.db, krate, ModItem::from(id).into());

let ast_id = InFile::new(self.file_id(), mac.ast_id.upcast());

let local_inner = if is_export {

tt::TtElement::Leaf(tt::Leaf::Ident(ident)) => ident.sym == sym::local_inner_macros,

_ => false,

})

};

// Case 1: builtin macros

// `#[rustc_builtin_macro = "builtin_name"]` overrides the `macro_rules!` name.

let name;

Some((it, span)) => {

name = Name::new_symbol(it.clone(), span.ctx);

&name

}

None => {

let explicit_name =

match tt.token_trees().flat_tokens().first() {

Some(tt::TokenTree::Leaf(tt::Leaf::Ident(name))) => Some(name),

_ => None,

// Case 2: normal `macro_rules!` macro

MacroExpander::Declarative

};

let mut flags = MacroRulesLocFlags::empty();

flags.set(MacroRulesLocFlags::LOCAL_INNER, local_inner);

edition: self.def_collector.def_map.data.edition,

}

.intern(self.def_collector.db);

self.def_collector.define_macro_rules(

self.module_id,

mac.name.clone(),

// Case 1: builtin macros

let mut helpers_opt = None;

let attrs = self.item_tree.attrs(self.def_collector.db, krate, ModItem::from(id).into());

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) {

// 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).

stdx::always!(

name == mac.name,

"built-in macro {} has #[rustc_builtin_macro] which declares different name {}",

);

helpers_opt = Some(helpers);

}

// Case 2: normal `macro`

MacroExpander::Declarative

};

let macro_id = Macro2Loc {

container: module,

edition: self.def_collector.def_map.data.edition,

}

.intern(self.def_collector.db);

self.def_collector.define_macro_def(

self.module_id,

mac.name.clone(),

// new legacy macros that create textual scopes. We need a way to resolve names in textual

// scopes without eager expansion.

// Case 1: try to resolve macro calls with single-segment name and expand macro_rules

if let Ok(res) = macro_call_as_call_id_with_eager(

ast_id.ast_id,

&ast_id.path,

ctxt,

},

|path| {

let resolved_res = self.def_collector.def_map.resolve_path_fp_with_macro(

db,

ResolveMode::Other,

self.module_id,

);

resolved_res.resolved_def.take_macros().map(|it| db.macro_def(it))

},

) {

// 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() {

#[cfg(test)]

mod tests {

use test_fixture::WithFixture;

use crate::{nameres::DefMapCrateData, test_db::TestDB};

let mut collector = DefCollector {

db,

def_map,

deps: FxHashMap::default(),

glob_imports: FxHashMap::default(),

unresolved_imports: Vec::new(),

let (db, file_id) = TestDB::with_single_file(not_ra_fixture);

let krate = db.test_crate();

let module_origin = ModuleOrigin::CrateRoot { definition: file_id };

let def_map = DefMap::empty(

krate,

// the release mode. That's why the argument is not an ra_fixture --

// otherwise injection highlighting gets stuck.

//

do_resolve(

r#"

macro_rules! foo {