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

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

use either::Either;

use hir_expand::{

mod_resolution::ModDir,

path_resolution::ReachedFixedPoint,

proc_macro::{parse_macro_name_and_helper_attrs, ProcMacroDef, ProcMacroKind},

},

path::{ImportAlias, ModPath, PathKind},

per_ns::{Item, PerNs},

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

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();

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

}

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

Name::new_symbol_root(sym::core.clone())

Name::new_symbol_root(sym::std.clone())

} else {

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

[krate, Name::new_symbol_root(sym::prelude.clone()), edition],

);

match per_ns.types {

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

}

}

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

///

/// # Notes on procedural macro resolution

) {

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

) {

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

};

let resolver = |path: &_| {

let resolved_res = self.def_map.resolve_path_fp_with_macro(

self.db,

ResolveMode::Other,

directive.module_id,

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

}

// Emit diagnostics for all remaining unexpanded macros.

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

self.def_map.krate,

|path| {

let resolved_res = self.def_map.resolve_path_fp_with_macro(

self.db,

ResolveMode::Other,

directive.module_id,

));

}

}

}

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

};

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

}

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

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

let mut index = 0;

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();

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

},

|path| {

let resolved_res = self.def_collector.def_map.resolve_path_fp_with_macro(

db,

ResolveMode::Other,

self.module_id,

#[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,