- AdtId, AstIdLoc, AttrDefId, FieldId, FunctionId, GenericDefId, HasModule, InternedModuleId,

- LifetimeParamId, LocalFieldId, MacroId, TypeOrConstParamId, VariantId,

- let id = id.loc(db);

- let (definition, declaration) = match def_map[id.local_id].origin {

- return (definition, declaration, id.krate);

- pub fn doc_keyword(db: &dyn DefDatabase, owner: InternedModuleId) -> Option<Symbol> {

- fn doc_keyword(db: &dyn DefDatabase, owner: InternedModuleId) -> Option<Symbol> {

- AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc, CrateRootModuleId, DefWithBodyId,

- EnumId, EnumLoc, EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId,

- ExternCrateLoc, FunctionId, FunctionLoc, GenericDefId, HasModule, ImplId, ImplLoc,

- InternedModuleId, LocalFieldId, Macro2Id, Macro2Loc, MacroExpander, MacroId, MacroRulesId,

- MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId, StaticLoc, StructId,

- StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc,

- VariantId,

-

- #[salsa::interned]

- fn intern_block(&self, loc: BlockLoc) -> BlockId;

- let root_module = CrateRootModuleId::from(crate_id).module(db);

- let attrs = AttrFlags::query(db, AttrDefId::ModuleId(InternedModuleId::new(db, root_module)));

- krate: loc.container.krate,

- krate: loc.container.krate,

- krate: loc.container.krate,

- AdtId, BlockId, BlockLoc, DefWithBodyId, FunctionId, GenericDefId, ImplId, MacroId,

- cfg_options: module.krate().cfg_options(db),

- self.lang_items.get_or_init(|| crate::lang_item::lang_items(self.db, self.module.krate))

- let module = self.module.local_id;

- let block_call = self.def_map.modules[self.module.local_id].scope.macro_invoc(

- module,

- self.module.krate(),

- let macro_id = self.def_map.modules[DefMap::ROOT].scope.get(&name).take_macros();

- let macro_id = self.def_map.modules[DefMap::ROOT]

- self.db.intern_block(BlockLoc { ast_id, module: self.module })

- (def_map.module_id(DefMap::ROOT), def_map)

- self.module.local_id,

- if self.module.krate().workspace_data(self.db).is_atleast_187() {

- module.def_map(&db).dump(&db)

- let actual = module.def_map(&db).dump_block_scopes(&db);

- BlockId(3801) in BlockRelativeModuleId { block: Some(BlockId(3800)), local_id: Idx::<ModuleData>(1) }

- BlockId(3800) in BlockRelativeModuleId { block: None, local_id: Idx::<ModuleData>(0) }

- crate scope

- "#]],

-fn is_visible_from_same_def_map() {

- - name : _

- FindPathConfig, ModuleDefId, ModuleId,

- from: ModuleId,

- if item_module.is_within_block() {

- cfg.prefer_no_std = cfg.prefer_no_std || db.crate_supports_no_std(from.krate());

- is_std_item: item_module.krate().data(db).origin.is_lang(),

- from_def_map: from.def_map(db),

- from: ModuleId,

-/// Attempts to find a path to refer to the given `item` visible from the `from` ModuleId

- PrefixKind::ByCrate => ctx.from.is_crate_root(),

-fn find_path_for_module(

- ctx: &FindPathCtx<'_>,

- visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,

- module_id: ModuleId,

- if let Some(crate_root) = module_id.as_crate_root() {

- if !maybe_extern || crate_root == ctx.from.derive_crate_root() {

- let root_local_def_map = ctx.from.derive_crate_root().local_def_map(ctx.db).1;

- if crate_root != def_id {

- .with_ancestor_maps(ctx.db, ctx.from.local_id, &mut |def_map, local_id| {

- .filter(|&(id, _)| id != ModuleDefId::ModuleId(def_id.into()))

- PrefixKind::ByCrate => ctx.from.is_crate_root(),

- ItemInNs::Types(module_id.into()),

- if let Some(kind) = is_kw_kind_relative_to_from(ctx.from_def_map, module_id, ctx.from)

- let item = ItemInNs::Types(module_id.into());

-fn find_in_scope(

- db: &dyn DefDatabase,

- from: ModuleId,

- def_map.with_ancestor_maps(db, from.local_id, &mut |def_map, local_id| {

- from: ModuleId,

- let prelude_scope = &prelude_def_map[prelude_module.local_id].scope;

- local_def_map.with_ancestor_maps(db, from.local_id, &mut |def_map, local_id| {

- item: ModuleId,

- from: ModuleId,

- if item.krate != from.krate || item.is_within_block() || from.is_within_block() {

- let item = item.local_id;

- let from = from.local_id;

- Some(if parent_id == DefMap::ROOT { PathKind::Crate } else { PathKind::Super(1) })

-fn calculate_best_path(

- ctx: &FindPathCtx<'_>,

- visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,

- ctx.from.krate()

- if item.krate(ctx.db) == Some(ctx.from.krate) {

- ctx.from.krate.data(ctx.db).dependencies.iter().for_each(|dep| {

-fn find_in_sysroot(

- ctx: &FindPathCtx<'_>,

- visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,

- let dependencies = &ctx.from.krate.data(ctx.db).dependencies;

-fn find_in_dep(

- ctx: &FindPathCtx<'_>,

- visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,

-fn calculate_best_path_local(

- ctx: &FindPathCtx<'_>,

- visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,

- find_local_import_locations(

- ctx.db,

- item,

- ctx.from,

- ctx.from_def_map,

- visited_modules,

- |visited_modules, name, module_id| {

- // we are looking for paths of length up to best_path_len, any longer will make it be

- // less optimal. The -1 is due to us pushing name onto it afterwards.

- if let Some(choice) = find_path_for_module(

- ctx,

- visited_modules,

- module_id,

- false,

- best_choice.as_ref().map_or(max_len, |it| it.path.len()) - 1,

- ) {

- Choice::try_select(best_choice, choice, ctx.cfg.prefer_prelude, name.clone());

- }

- },

- );

-fn find_local_import_locations(

- db: &dyn DefDatabase,

- from: ModuleId,

- def_map: &DefMap,

- visited_modules: &mut FxHashSet<(ItemInNs, ModuleId)>,

- mut cb: impl FnMut(&mut FxHashSet<(ItemInNs, ModuleId)>, &Name, ModuleId),

- let mut worklist = def_map[from.local_id]

- .map(|&child| def_map.module_id(child))

- .chain(iter::successors(from.containing_module(db), |m| m.containing_module(db)))

- let def_map = def_map.crate_root().def_map(db);

- let data = if module.block.is_some() {

- &block_def_map[module.local_id]

- &def_map[module.local_id]

- && vis.is_visible_from(db, from)

- if module.krate != from.krate {

- if vis.is_visible_from(db, from) {

- module.local_id,

- AssocItemId, AttrDefId, Complete, FxIndexMap, InternedModuleId, ModuleDefId, ModuleId, TraitId,

- nameres::{DefMap, assoc::TraitItems, crate_def_map},

- let root = def_map.module_id(DefMap::ROOT);

- let ext_def_map;

- let mod_data = if module.krate == krate {

- &def_map[module.local_id]

- ext_def_map = module.def_map(db);

- &ext_def_map[module.local_id]

- ModuleDefId::ModuleId(it) => {

- Some(AttrDefId::ModuleId(InternedModuleId::new(db, it)))

- }

- use crate::{ItemContainerId, Lookup, nameres::assoc::TraitItems, test_db::TestDB};

- fn render_path(db: &dyn DefDatabase, info: &ImportInfo) -> String {

- let mut module = info.container;

- let parent_data = &def_map[parent.local_id];

- let (name, _) =

- parent_data.children.iter().find(|(_, id)| **id == module.local_id).unwrap();

- LocalModuleId, Lookup, MacroCallStyles, MacroId, ModuleDefId, ModuleId, TraitId, UseId,

- types: FxHashSet<(LocalModuleId, Name)>,

- values: FxHashSet<(LocalModuleId, Name)>,

- macros: FxHashSet<(LocalModuleId, Name)>,

- pub(crate) fn contains_type(&self, module_id: LocalModuleId, name: Name) -> bool {

- pub(crate) fn contains_value(&self, module_id: LocalModuleId, name: Name) -> bool {

- pub(crate) fn contains_macro(&self, module_id: LocalModuleId, name: Name) -> bool {

- let mut def_map;

- def_map = module_id.def_map(db);

- scope = &def_map[module_id.local_id].scope;

- def_map = module_id.def_map(db);

- scope = &def_map[module_id.local_id].scope;

- def_map = module_id.def_map(db);

- scope = &def_map[module_id.local_id].scope;

- lookup: (LocalModuleId, Name),

- match self {

- ItemInNs::Types(id) | ItemInNs::Values(id) => id.module(db).map(|m| m.krate),

- ItemInNs::Macros(id) => Some(id.module(db).krate),

- }

-use crate::{BlockId, Lookup, db::DefDatabase};

- let loc = block.lookup(db);

- let block = loc.ast_id.to_node(db);

- let ctx = lower::Ctx::new(db, loc.ast_id.file_id);

- for (_, (krate, _)) in crate_local_def_map(db, start_crate).local(db).extern_prelude() {

- if krate.krate != start_crate {

- result.merge_prefer_self(lang_items(db, krate.krate));

-use la_arena::Idx;

- pub container: CrateRootModuleId,

-impl_loc!(ProcMacroLoc, id: Fn, container: CrateRootModuleId);

-#[derive(Debug, Hash, PartialEq, Eq, Clone)]

-pub struct BlockLoc {

- pub module: ModuleId,

-}

-impl_intern!(BlockId, BlockLoc, intern_block, lookup_intern_block);

-

-/// A `ModuleId` that is always a crate's root module.

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

-pub struct CrateRootModuleId {

- krate: Crate,

-}

-

-impl CrateRootModuleId {

- pub fn def_map(self, db: &dyn DefDatabase) -> &DefMap {

- crate_def_map(db, self.krate)

- }

-

- pub(crate) fn local_def_map(self, db: &dyn DefDatabase) -> (&DefMap, &LocalDefMap) {

- let def_map = crate_local_def_map(db, self.krate);

- (def_map.def_map(db), def_map.local(db))

- }

-

- pub fn krate(self) -> Crate {

- self.krate

- }

-}

-

-impl HasModule for CrateRootModuleId {

- #[inline]

- fn module(&self, _db: &dyn DefDatabase) -> ModuleId {

- ModuleId { krate: self.krate, block: None, local_id: DefMap::ROOT }

- }

-

- #[inline]

- fn krate(&self, _db: &dyn DefDatabase) -> Crate {

- self.krate

- }

-}

-

-impl PartialEq<ModuleId> for CrateRootModuleId {

- fn eq(&self, other: &ModuleId) -> bool {

- other.block.is_none() && other.local_id == DefMap::ROOT && self.krate == other.krate

- }

-}

-impl PartialEq<CrateRootModuleId> for ModuleId {

- fn eq(&self, other: &CrateRootModuleId) -> bool {

- other == self

- }

-}

-

-impl From<CrateRootModuleId> for ModuleId {

- fn from(CrateRootModuleId { krate }: CrateRootModuleId) -> Self {

- ModuleId { krate, block: None, local_id: DefMap::ROOT }

- }

-impl From<CrateRootModuleId> for ModuleDefId {

- fn from(value: CrateRootModuleId) -> Self {

- ModuleDefId::ModuleId(value.into())

- }

-}

-

-impl From<Crate> for CrateRootModuleId {

- fn from(krate: Crate) -> Self {

- CrateRootModuleId { krate }

-

-impl TryFrom<ModuleId> for CrateRootModuleId {

- type Error = ();

-

- fn try_from(ModuleId { krate, block, local_id }: ModuleId) -> Result<Self, Self::Error> {

- if block.is_none() && local_id == DefMap::ROOT {

- Ok(CrateRootModuleId { krate })

- } else {

- Err(())

- }

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

-pub struct ModuleId {

- krate: Crate,

- block: Option<BlockId>,

- /// The module's ID in its originating `DefMap`.

- pub local_id: LocalModuleId,

-impl ModuleId {

- pub fn def_map(self, db: &dyn DefDatabase) -> &DefMap {

- match self.block {

- None => crate_def_map(db, self.krate),

- pub(crate) fn local_def_map(self, db: &dyn DefDatabase) -> (&DefMap, &LocalDefMap) {

- match self.block {

- let def_map = crate_local_def_map(db, self.krate);

- pub(crate) fn only_local_def_map(self, db: &dyn DefDatabase) -> &LocalDefMap {

- crate_local_def_map(db, self.krate).local(db)

- }

-

- pub fn crate_def_map(self, db: &dyn DefDatabase) -> &DefMap {

- crate_def_map(db, self.krate)

- pub fn krate(self) -> Crate {

- self.krate

- pub fn name(self, db: &dyn DefDatabase) -> Option<Name> {

- let parent = def_map[self.local_id].parent?;

- if *module_id == self.local_id { Some(name.clone()) } else { None }

- pub fn containing_module(self, db: &dyn DefDatabase) -> Option<ModuleId> {

- self.def_map(db).containing_module(self.local_id)

- }

-

- pub fn containing_block(self) -> Option<BlockId> {

- self.block

- }

-

- pub fn is_block_module(self) -> bool {

- self.block.is_some() && self.local_id == DefMap::ROOT

- pub fn is_within_block(self) -> bool {

- self.block.is_some()

- }

-

- /// Returns the [`CrateRootModuleId`] for this module if it is the crate root module.

- pub fn as_crate_root(&self) -> Option<CrateRootModuleId> {

- if self.local_id == DefMap::ROOT && self.block.is_none() {

- Some(CrateRootModuleId { krate: self.krate })

- } else {

- None

- }

- }

-

- /// Returns the [`CrateRootModuleId`] for this module.

- pub fn derive_crate_root(&self) -> CrateRootModuleId {

- CrateRootModuleId { krate: self.krate }

- /// Whether this module represents the crate root module

- pub fn is_crate_root(&self) -> bool {

- self.local_id == DefMap::ROOT && self.block.is_none()

-/// An ID of a module, **local** to a `DefMap`.

-pub type LocalModuleId = Idx<nameres::ModuleData>;

-

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

-// FIXME: We probably should use this in more places.

-/// This is used to avoid interning the whole `AttrDefId`, so we intern just modules and not everything.

-#[salsa_macros::interned(debug, no_lifetime)]

-pub struct InternedModuleId {

- pub loc: ModuleId,

-}

-

- ModuleId(InternedModuleId),

- self.module(db).krate

- self.lookup(db).container.into()

- AttrDefId::ModuleId(it) => it.loc(db),

-struct#0:MacroRules[BE8F, 0]@58..64#14336# MyTraitMap2#0:MacroCall[BE8F, 0]@31..42#ROOT2024# {#0:MacroRules[BE8F, 0]@72..73#14336#

- map#0:MacroRules[BE8F, 0]@86..89#14336#:#0:MacroRules[BE8F, 0]@89..90#14336# #0:MacroRules[BE8F, 0]@89..90#14336#::#0:MacroRules[BE8F, 0]@91..93#14336#std#0:MacroRules[BE8F, 0]@93..96#14336#::#0:MacroRules[BE8F, 0]@96..98#14336#collections#0:MacroRules[BE8F, 0]@98..109#14336#::#0:MacroRules[BE8F, 0]@109..111#14336#HashSet#0:MacroRules[BE8F, 0]@111..118#14336#<#0:MacroRules[BE8F, 0]@118..119#14336#(#0:MacroRules[BE8F, 0]@119..120#14336#)#0:MacroRules[BE8F, 0]@120..121#14336#>#0:MacroRules[BE8F, 0]@121..122#14336#,#0:MacroRules[BE8F, 0]@122..123#14336#

-}#0:MacroRules[BE8F, 0]@132..133#14336#

-struct#1:MacroRules[DB0C, 0]@59..65#14336# Foo#0:MacroCall[DB0C, 0]@32..35#ROOT2024#(#1:MacroRules[DB0C, 0]@70..71#14336#u32#0:MacroCall[DB0C, 0]@41..44#ROOT2024#)#1:MacroRules[DB0C, 0]@74..75#14336#;#1:MacroRules[DB0C, 0]@75..76#14336#

-impl#\14336# Bar#\14336# {#\14336#

- fn#\14336# foo#\ROOT2024#(#\14336#)#\14336# {#\14336#}#\14336#

- fn#\14336# bar#\ROOT2024#(#\14336#)#\14336# {#\14336#}#\14336#

-}#\14336#

- let local_id = DefMap::ROOT;

- let source = def_map[local_id].definition_source(&db);

- for decl_id in def_map[local_id].scope.declarations() {

- for impl_id in def_map[local_id].scope.impls() {

-use std::ops::Deref;

-use la_arena::Arena;

- AstId, BlockId, BlockLoc, CrateRootModuleId, ExternCrateId, FunctionId, FxIndexMap,

- LocalModuleId, Lookup, MacroCallStyles, MacroExpander, MacroId, ModuleId, ProcMacroId, UseId,

- extern_prelude: FxIndexMap<Name, (CrateRootModuleId, Option<ExternCrateId>)>,

- ) -> impl DoubleEndedIterator<Item = (&Name, (CrateRootModuleId, Option<ExternCrateId>))> + '_

- {

- pub modules: Arena<ModuleData>,

- parent: BlockRelativeModuleId,

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

-struct BlockRelativeModuleId {

- block: Option<BlockId>,

- local_id: LocalModuleId,

-}

-

-impl BlockRelativeModuleId {

- fn def_map(self, db: &dyn DefDatabase, krate: Crate) -> &DefMap {

- self.into_module(krate).def_map(db)

- }

-

- fn into_module(self, krate: Crate) -> ModuleId {

- ModuleId { krate, block: self.block, local_id: self.local_id }

- }

- fn is_block_module(self) -> bool {

- self.block.is_some() && self.local_id == DefMap::ROOT

-impl std::ops::Index<LocalModuleId> for DefMap {

- type Output = ModuleData;

- fn index(&self, id: LocalModuleId) -> &ModuleData {

- &self.modules[id]

- pub parent: Option<LocalModuleId>,

- pub children: FxIndexMap<Name, LocalModuleId>,

- let module_data =

- ModuleData::new(ModuleOrigin::CrateRoot { definition: root_file_id }, Visibility::Public);

- let def_map =

- DefMap::empty(crate_id, Arc::new(DefMapCrateData::new(krate.edition)), module_data, None);

-pub fn block_def_map(db: &dyn DefDatabase, block_id: BlockId) -> DefMap {

- let BlockLoc { ast_id, module } = block_id.lookup(db);

- let visibility = Visibility::Module(

- ModuleId { krate: module.krate, local_id: DefMap::ROOT, block: module.block },

- VisibilityExplicitness::Implicit,

- );

- ModuleData::new(ModuleOrigin::BlockExpr { block: ast_id, id: block_id }, visibility);

- let local_def_map = crate_local_def_map(db, module.krate);

- module.krate,

- Some(BlockInfo {

- block: block_id,

- parent: BlockRelativeModuleId { block: module.block, local_id: module.local_id },

- }),

- /// The module id of a crate or block root.

- pub const ROOT: LocalModuleId = LocalModuleId::from_raw(la_arena::RawIdx::from_u32(0));

-

- let mut modules: Arena<ModuleData> = Arena::default();

- let root = modules.alloc(module_data);

- assert_eq!(root, Self::ROOT);

- ) -> impl Iterator<Item = LocalModuleId> + 'a {

- pub fn modules(&self) -> impl Iterator<Item = (LocalModuleId, &ModuleData)> + '_ {

- pub fn module_id(&self, local_id: LocalModuleId) -> ModuleId {

- let block = self.block.map(|b| b.block);

- ModuleId { krate: self.krate, local_id, block }

- }

-

- pub fn crate_root(&self) -> CrateRootModuleId {

- CrateRootModuleId { krate: self.krate }

- self.module_id(Self::ROOT)

- let BlockRelativeModuleId { block, local_id } = self.block?.parent;

- Some(ModuleId { krate: self.krate, block, local_id })

- pub fn containing_module(&self, local_mod: LocalModuleId) -> Option<ModuleId> {

- Some(parent) => Some(self.module_id(parent)),

- None => {

- self.block.map(

- |BlockInfo { parent: BlockRelativeModuleId { block, local_id }, .. }| {

- ModuleId { krate: self.krate, block, local_id }

- },

- )

- }

- let mut arc;

- go(&mut buf, db, current_map, "(block scope)", Self::ROOT);

- arc = block.parent.def_map(db, self.krate);

- current_map = arc;

- go(&mut buf, db, current_map, "crate", Self::ROOT);

- fn go(

- buf: &mut String,

- db: &dyn DefDatabase,

- map: &DefMap,

- path: &str,

- module: LocalModuleId,

- ) {

- map.modules[module].scope.dump(db, buf);

- for (name, child) in

- map.modules[module].children.iter().sorted_by(|a, b| Ord::cmp(&a.0, &b.0))

-

- pub fn dump_block_scopes(&self, db: &dyn DefDatabase) -> String {

- let mut buf = String::new();

- let mut arc;

- let mut current_map = self;

- while let Some(block) = current_map.block {

- format_to!(buf, "{:?} in {:?}\n", block.block, block.parent);

- arc = block.parent.def_map(db, self.krate);

- current_map = arc;

- }

-

- format_to!(buf, "crate scope\n");

- buf

- }

- original_module: LocalModuleId,

- original_module: LocalModuleId,

- pub(crate) fn with_ancestor_maps<T>(

- db: &dyn DefDatabase,

- local_mod: LocalModuleId,

- f: &mut dyn FnMut(&DefMap, LocalModuleId) -> Option<T>,

- let parent = block_info.parent.def_map(db, self.krate);

- if let Some(it) = f(parent, block_info.parent.local_id) {

- pub(crate) fn new(origin: ModuleOrigin, visibility: Visibility) -> Self {

- parent: None,

- cfg_options: module_id.krate.cfg_options(db),

- self.module_id.local_id,

- self.module_id.local_id,

- if let Some(err) = exp.as_expand_error(self.module_id.krate) {

- self.module_id.local_id,

- self.module_id.local_id,

- self.module_id.local_id,

- self.module_id.krate(),

- self.module_id.local_id,

- AstIdWithPath, LocalModuleId, MacroId, UnresolvedMacro,

- original_module: LocalModuleId,

-use std::{cmp::Ordering, iter, mem};

- AdtId, AssocItemId, AstId, AstIdWithPath, ConstLoc, CrateRootModuleId, EnumLoc, ExternBlockLoc,

- ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc, FxIndexMap, ImplLoc, Intern,

- ItemContainerId, LocalModuleId, Lookup, Macro2Id, Macro2Loc, MacroExpander, MacroId,

- MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ModuleDefId, ModuleId, ProcMacroId,

- ProcMacroLoc, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc, UnresolvedMacro, UseId,

- UseLoc,

- module_id: LocalModuleId,

- module_id: LocalModuleId,

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

- mod_dirs: FxHashMap<LocalModuleId, ModDir>,

- self.local_def_map

- .extern_prelude

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

- module_id: DefMap::ROOT,

- module_id: DefMap::ROOT,

- let root = &mut self.def_map.modules[DefMap::ROOT];

- DefMap::ROOT,

- container: self.def_map.crate_root(),

- module_id: LocalModuleId,

- let module_id = DefMap::ROOT;

- fn define_legacy_macro(&mut self, module_id: LocalModuleId, name: Name, mac: MacroId) {

- module_id: LocalModuleId,

- let module_id = DefMap::ROOT;

- let root_scope = &def_map[DefMap::ROOT].scope;

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

- } else if m.krate != self.def_map.krate {

- let item_map = m.def_map(self.db);

- let scope = &item_map[m.local_id].scope;

- let def_map;

- let scope = if m.block == self.def_map.block_id() {

- &self.def_map[m.local_id].scope

- def_map = m.def_map(self.db);

- &def_map[m.local_id].scope

- let glob_imports = self.glob_imports.entry(m.local_id).or_default();

- if let Some(new_vis) = old_vis.max(vis, &self.def_map) {

- module_id: LocalModuleId,

- self.db.unwind_if_revision_cancelled();

- module_id: LocalModuleId,

- let max_vis = old_vis.max(vis, &self.def_map).unwrap_or_else(|| {

- let vis = glob_import_vis.min(vis, &self.def_map).unwrap_or(glob_import_vis);

- module_id: LocalModuleId,

- def.vis = def.vis.min(vis, &self.def_map).unwrap_or(vis);

- def.vis = def.vis.min(vis, &self.def_map).unwrap_or(vis);

- def.vis = def.vis.min(vis, &self.def_map).unwrap_or(vis);

- && def.vis.max(prev_def.vis, &self.def_map) == Some(def.vis)

- && def.vis.max(prev_def.vis, &self.def_map) == Some(def.vis)

- && def.vis.max(prev_def.vis, &self.def_map) == Some(def.vis)

- module_id: LocalModuleId,

- module_id: LocalModuleId,

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

- self.collect(items, module.into())

- let is_crate_root =

- self.module_id == DefMap::ROOT && self.def_collector.def_map.block.is_none();

- if prelude_module.krate != krate && is_crate_root {

- prelude_module.krate,

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

- let id =

- UseLoc { container: module, id: InFile::new(self.file_id(), item_tree_id) }

- .intern(db);

- container: module,

- Some(def_map.crate_root())

- .map(|dep| CrateRootModuleId { krate: dep.crate_id })

- resolved.krate,

- container: module,

- ModItemId::MacroRules(id) => self.collect_macro_rules(id, module),

- ModItemId::Macro2(id) => self.collect_macro_def(id, module),

- ImplLoc { container: module, id: InFile::new(self.file_id(), imp) }

- && self.module_id == DefMap::ROOT

- StructLoc { container: module, id: InFile::new(self.file_id(), id) }

- UnionLoc { container: module, id: InFile::new(self.file_id(), id) }

- let enum_ =

- EnumLoc { container: module, id: InFile::new(self.tree_id.file_id(), id) }

- .intern(db);

- TraitLoc { container: module, id: InFile::new(self.file_id(), id) }

- ) -> LocalModuleId {

- let def_map = &mut self.def_collector.def_map;

- let vis = def_map

- let res = modules.alloc(ModuleData::new(origin, vis));

- modules[res].parent = Some(self.module_id);

-

- if let Some((target, source)) = Self::borrow_modules(modules.as_mut(), res, self.module_id)

- {

- for (name, macs) in source.scope.legacy_macros() {

- for &mac in macs {

- target.scope.define_legacy_macro(name.clone(), mac);

- }

- modules[self.module_id].children.insert(name.clone(), res);

- let module = def_map.module_id(res);

- res

- fn import_all_legacy_macros(&mut self, module_id: LocalModuleId) {

- let Some((source, target)) = Self::borrow_modules(

- self.def_collector.def_map.modules.as_mut(),

- module_id,

- self.module_id,

- ) else {

- /// Mutably borrow two modules at once, retu

- fn borrow_modules(

- modules: &mut [ModuleData],

- a: LocalModuleId,

- b: LocalModuleId,

- ) -> Option<(&mut ModuleData, &mut ModuleData)> {

- let a = a.into_raw().into_u32() as usize;

- let b = b.into_raw().into_u32() as usize;

-

- let (a, b) = match a.cmp(&b) {

- Ordering::Equal => return None,

- Ordering::Less => {

- let (prefix, b) = modules.split_at_mut(b);

- (&mut prefix[a], &mut b[0])

- }

- Ordering::Greater => {

- let (prefix, a) = modules.split_at_mut(a);

- (&mut a[0], &mut prefix[b])

- }

- };

- Some((a, b))

- }

-

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

- fn do_collect_defs(db: &dyn DefDatabase, def_map: DefMap) -> DefMap {

- let mut collector = DefCollector {

- db,

- def_map,

- local_def_map: LocalDefMap::default(),

- crate_local_def_map: None,

- deps: FxIndexMap::default(),

- glob_imports: FxHashMap::default(),

- unresolved_imports: Vec::new(),

- indeterminate_imports: Vec::new(),

- unresolved_macros: Vec::new(),

- mod_dirs: FxHashMap::default(),

- cfg_options: &CfgOptions::default(),

- proc_macros: Default::default(),

- from_glob_import: Default::default(),

- skip_attrs: Default::default(),

- prev_active_attrs: Default::default(),

- is_proc_macro: false,

- unresolved_extern_crates: Default::default(),

- };

- collector.seed_with_top_level();

- collector.collect();

- collector.def_map

- }

-

- fn do_resolve(not_ra_fixture: &str) -> DefMap {

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

- let edition = krate.data(&db).edition;

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

- let def_map = DefMap::empty(

- krate,

- Arc::new(DefMapCrateData::new(edition)),

- ModuleData::new(module_origin, Visibility::Public),

- None,

- );

- do_collect_defs(&db, def_map)

-use crate::{AstId, nameres::LocalModuleId};

- pub in_module: LocalModuleId,

- container: LocalModuleId,

- container: LocalModuleId,

- container: LocalModuleId,

- container: LocalModuleId,

- container: LocalModuleId,

- container: LocalModuleId,

- pub(super) fn unimplemented_builtin_macro(

- container: LocalModuleId,

- ast: AstId<ast::Macro>,

- ) -> Self {

- container: LocalModuleId,

- pub(super) fn malformed_derive(

- container: LocalModuleId,

- ast: AstId<ast::Adt>,

- id: AttrId,

- ) -> Self {

- AdtId, LocalModuleId, ModuleDefId,

- original_module: LocalModuleId,

- if self.block_id() != m.block && !within_impl {

- vis = Visibility::Module(self.module_id(Self::ROOT), mv);

- Visibility::Module(self.module_id(original_module), *explicitness)

- mut original_module: LocalModuleId,

- Some(block) if original_module == Self::ROOT => {

- original_module = block.parent.local_id;

- current_map = block.parent.def_map(db, current_map.krate);

- if original_module != Self::ROOT && current_map.block.is_some() {

- original_module = Self::ROOT;

- original_module: LocalModuleId,

- PerNs::types(self.crate_root().into(), Visibility::Public, None)

- let module = def_map.module_id(Self::ROOT);

- PathKind::Crate => PerNs::types(self.crate_root().into(), Visibility::Public, None),

- let mut ext;

- if def_map.module_id(local_id).is_block_module() {

- (ext, local_id) = adjust_to_nearest_non_block_module(db, def_map, local_id);

- def_map = ext;

- }

- local_id = parent;

- if def_map.module_id(local_id).is_block_module() {

- (ext, local_id) =

- adjust_to_nearest_non_block_module(db, def_map, local_id);

- def_map = ext;

- }

- let module = def_map.module_id(local_id);

- stdx::never!(module.is_block_module());

-

- PerNs::types(module.into(), Visibility::Public, None)

- original_module: LocalModuleId,

- original_module: LocalModuleId,

- if module.krate != self.krate {

- module.local_id,

- let module_data = if module.block == self.block_id() {

- &self[module.local_id]

- &def_map[module.local_id]

- module: LocalModuleId,

- if self.block.is_some() && module == DefMap::ROOT {

- if self.block.is_some() && module == DefMap::ROOT {

- module: LocalModuleId,

- let def_map = self.crate_root().def_map(db);

- def_map[Self::ROOT].scope.get(name)

- None => self[Self::ROOT].scope.get(name),

- if self.block.is_some() && module == DefMap::ROOT {

- let def_map = if prelude.krate == self.krate {

- def_map[prelude.local_id].scope.get(name)

- def_map: &'db DefMap,

- mut local_id: LocalModuleId,

-) -> (&'db DefMap, LocalModuleId) {

- // INVARIANT: `local_id` in `def_map` must be a block module.

- stdx::always!(def_map.module_id(local_id).is_block_module());

-

- // This needs to be a local variable due to our mighty lifetime.

- let mut def_map = def_map;

- loop {

- let BlockInfo { parent, .. } = def_map.block.expect("block module without parent module");

-

- def_map = parent.def_map(db, def_map.krate);

- local_id = parent.local_id;

- if !parent.is_block_module() {

- // Add a dependency a -> b.

- &[("crate_local_def_map", 1)],

- "crate_local_def_map",

- "proc_macros_for_crate_shim",

- "crate_local_def_map",

- "proc_macros_for_crate_shim",

- "file_item_tree_query",

- "ast_id_map_shim",

- "parse_shim",

- "real_span_map_shim",

- let (_, module_data) = crate_def_map.modules.iter().last().unwrap();

- let (_, module_data) = crate_def_map.modules.iter().last().unwrap();

- |map| assert_eq!(map.modules[DefMap::ROOT].scope.impls().len(), 1),

- |map| assert_eq!(map.modules[DefMap::ROOT].scope.impls().len(), 2),

- |map| assert_eq!(map.modules[DefMap::ROOT].scope.impls().len(), 1),

- let root_module = &def_map[DefMap::ROOT].scope;

- |map| assert_eq!(map.modules[DefMap::ROOT].scope.impls().len(), 1),

- AdtId, AstIdLoc, ConstId, ConstParamId, CrateRootModuleId, DefWithBodyId, EnumId,

- EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, FxIndexMap, GenericDefId,

- GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalModuleId, Lookup,

- Macro2Id, MacroId, MacroRulesId, ModuleDefId, ModuleId, ProcMacroId, StaticId, StructId,

- TraitId, TypeAliasId, TypeOrConstParamId, TypeParamId, UseId, VariantId,

- module_id: LocalModuleId,

- res.add(name, ScopeDef::ModuleDef(ModuleDefId::ModuleId(def.into())));

- for (name, def) in prelude_def_map[prelude.local_id].scope.entries() {

- .map(|(name, module_id)| (name.clone(), module_id.0.into()))

- traits.extend(prelude_def_map[prelude.local_id].scope.traits());

- let (def_map, _, local_id) = self.item_scope_();

- def_map.module_id(local_id)

- let local_def_map = block.lookup(db).module.only_local_def_map(db);

- module_id: DefMap::ROOT,

- fn item_scope_(&self) -> (&DefMap, &LocalDefMap, LocalModuleId) {

- let local_def_map = block.lookup(db).module.only_local_def_map(db);

- r = r.push_block_scope(def_map, local_def_map, DefMap::ROOT);

- module_id: LocalModuleId,

- let mut module_id = self.local_id;

- if !self.is_within_block() {

- let block_module_id = mem::replace(&mut module_id, parent.local_id);

- if !parent.is_within_block() {

-impl HasResolver for CrateRootModuleId {

- fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {

- let (def_map, local_def_map) = self.local_def_map(db);

- Resolver {

- scopes: vec![],

- module_scope: ModuleItemMap { def_map, local_def_map, module_id: DefMap::ROOT },

- }

- }

-}

-

- let cfg_options = module.krate.cfg_options(db);

- let cfg_options = loc.container.krate.cfg_options(db);

- let cfg_options = container.krate.cfg_options(db);

- let cfg_options = container.krate.cfg_options(db);

- LocalModuleId, Lookup, ModuleDefId, ModuleId,

- return crate_def_map.module_id(local_id);

- None => return def_map.module_id(module),

- return def_map.module_id(DefMap::ROOT);

- fn mod_at_position(&self, def_map: &DefMap, position: FilePosition) -> LocalModuleId {

- let mut res = DefMap::ROOT;

- AssocItemId, HasModule, ItemContainerId, LocalFieldId, LocalModuleId, ModuleId, TraitId,

- pub fn is_visible_from(self, db: &dyn DefDatabase, from_module: ModuleId) -> bool {

- Visibility::Module(m, _) => m,

- Visibility::PubCrate(krate) => return from_module.krate == krate,

- if from_module.krate != to_module.krate {

- Self::is_visible_from_def_map_(db, def_map, to_module, from_module.local_id)

- pub(crate) fn is_visible_from_def_map(

- db: &dyn DefDatabase,

- def_map: &DefMap,

- from_module: LocalModuleId,

- Visibility::PubCrate(krate) => return def_map.krate() == krate,

- if def_map.krate() != to_module.krate {

- if from_module == to_module.local_id && def_map.block_id() == to_module.block {

- fn is_visible_from_def_map_(

- db: &dyn DefDatabase,

- def_map: &DefMap,

- mut to_module: ModuleId,

- mut from_module: LocalModuleId,

- debug_assert_eq!(to_module.krate, def_map.krate());

- match (to_module.block, def_map_block) {

- if def_map.module_id(from_module) == to_module {

- from_module = module.local_id;

- pub(crate) fn max(self, other: Visibility, def_map: &DefMap) -> Option<Visibility> {

- if mod_.krate == krate {

- Some(Visibility::PubCrate(krate))

- } else {

- None

- }

- if mod_a.krate() != def_map.krate() || mod_b.krate() != def_map.krate() {

- if mod_a.containing_block() != def_block || mod_b.containing_block() != def_block {

- let mut a_ancestors =

- iter::successors(Some(mod_a.local_id), |&m| def_map[m].parent);

- if a_ancestors.any(|m| m == mod_b.local_id) {

- let mut b_ancestors =

- iter::successors(Some(mod_b.local_id), |&m| def_map[m].parent);

- if b_ancestors.any(|m| m == mod_a.local_id) {

- pub(crate) fn min(self, other: Visibility, def_map: &DefMap) -> Option<Visibility> {

- if mod_.krate == krate { Some(Visibility::Module(mod_, exp)) } else { None }

- if mod_a == mod_b {

- if mod_a.krate() != def_map.krate() || mod_b.krate() != def_map.krate() {

- if mod_a.containing_block() != def_block || mod_b.containing_block() != def_block {

- let mut a_ancestors =

- iter::successors(Some(mod_a.local_id), |&m| def_map[m].parent);

- if a_ancestors.any(|m| m == mod_b.local_id) {

- let mut b_ancestors =

- iter::successors(Some(mod_b.local_id), |&m| def_map[m].parent);

- if b_ancestors.any(|m| m == mod_a.local_id) {

- ($(($name:ident, $variant:ident) => $expand:ident),* ) => {

- (test_case, TestCase) => dummy_gate_test_expand

- if path.segments.len() != 1

-

- if path.segments.len() == 1 {

- let name = path.segments[0].text();

-

- if name == "cfg" {

- let cfg_expr = CfgExpr::parse_from_ast(

- &mut TokenTreeChildren::new(&tt).peekable(),

- );

- if cfg_options().check(&cfg_expr) == Some(false) {

- return ControlFlow::Break(ItemIsCfgedOut);

- }

- strip_current_attr = true;

- }

- }

- let scope = &def_map[module_id.local_id].scope;

- let module_data = &module_id.def_map(self.db)[module_id.local_id];

- let is_local = adt.krate(self.db) == self.module.krate();

- let krate = resolver.module().krate();

- nameres::DefMap,

- let interner = DbInterner::new_with(db, module_id.krate());

- display_target: DisplayTarget::from_crate(db, module_id.krate()),

- let krate = param.id.parent().module(db).krate();

- let root_module_id = def_map.module_id(DefMap::ROOT);

- } else if root_module_id == vis_id && !root_module_id.is_within_block() {

- } else if module_id.containing_module(f.db) == Some(vis_id) && !vis_id.is_block_module()

- let impls = match module.containing_block() {

- None => TraitImpls::for_crate(db, module.krate()),

- AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,

- TypeAliasId, TypeOrConstParamId, TypeParamId, hir::generics::LocalTypeOrConstParamId,

- signatures::TraitFlags,

- let krate = def.module(db).krate();

- let def_map = CrateRootModuleId::from(trait_.krate(db)).def_map(db);

- let interner = DbInterner::new_with(db, module.krate());

- let scope = &def_map[module_id.local_id].scope;

- adjustments

- .iter()

- .filter(|adj| {

- // https://github.com/rust-lang/rust/blob/67819923ac8ea353aaa775303f4c3aacbf41d010/compiler/rustc_mir_build/src/thir/cx/expr.rs#L140

- !matches!(

- adj,

- Adjustment {

- kind: Adjust::NeverToAny,

- target,

- } if target.is_never()

- )

- })

- .next_back()

- ctx.owner.module(ctx.db).krate(),

- if is_raw_identifier(&result, owner.module(db).krate().data(db).edition) {

- self.owner.module(self.db).krate(),

- let scope = &def_map[module_id.local_id].scope;

- let scope = &def_map[module_id.local_id].scope;

- let interner = DbInterner::new_with(db, module.krate());

-

- let interner = DbInterner::new_with(db, module.krate());

- AssocItemId, BlockId, ConstId, FunctionId, GenericParamId, HasModule, ImplId, ItemContainerId,

- ModuleId, TraitId,

-impl InherentImpls {

- pub fn for_crate(db: &dyn HirDatabase, krate: Crate) -> Self {

- pub fn for_block(db: &dyn HirDatabase, block: BlockId) -> Option<Box<Self>> {

- pub fn for_each_crate_and_block(

- db: &dyn HirDatabase,

- block: Option<BlockId>,

- let blocks = std::iter::successors(block, |block| block.loc(db).module.containing_block());

-impl TraitImpls {

- pub fn for_crate(db: &dyn HirDatabase, krate: Crate) -> Arc<Self> {

- pub fn for_block(db: &dyn HirDatabase, block: BlockId) -> Option<Box<Self>> {

- pub fn for_crate_and_deps(db: &dyn HirDatabase, krate: Crate) -> Box<[Arc<Self>]> {

- pub fn for_each_crate_and_block(

- db: &dyn HirDatabase,

- block: Option<BlockId>,

- let blocks = std::iter::successors(block, |block| block.loc(db).module.containing_block());

- pub fn for_each_crate_and_block_trait_and_type(

- db: &dyn HirDatabase,

- type_block: Option<BlockId>,

- trait_block: Option<BlockId>,

- let blocks_iter = |block: Option<BlockId>| {

- std::iter::successors(block, |block| block.loc(db).module.containing_block())

- let for_each_block = |current_block: Option<BlockId>, other_block: Option<BlockId>| {

- module.krate(),

- module.containing_block(),

- let interner = DbInterner::new_with(db, module.krate());

- body.owner.module(db).krate(),

- body.owner.module(db).krate(),

- body.owner.module(db).krate(),

- let crate_id = module.krate();

- let scope = &def_map[module_id.local_id].scope;

- let krate = db.module_for_file(file_id.file_id(&db)).krate();

- let scope = &def_map[module_id.local_id].scope;

- if self.is_struct() {

- let tail_ty = self.all_field_tys(interner).skip_binder().into_iter().last()?;

-

- let constraint_ty = sizedness_constraint_for_ty(interner, sizedness, tail_ty)?;

-

- Some(EarlyBinder::bind(constraint_ty))

- } else {

- None

- }

- let trait_block = trait_def_id.0.loc(self.db).container.containing_block();

- module.containing_block()

- let block = trait_def_id.0.loc(self.db).container.containing_block();

- let krate = owner.module(db).krate();

- Adt(adt, args) => {

- let tail_ty =

- EarlyBinder::bind(adt.all_field_tys(interner).skip_binder().into_iter().last()?)

- .instantiate(interner, args);

- }

- let interner = DbInterner::new_with(db, module.krate());

- let def_map = crate_def_map(db, module.krate());

- for (local_id, data) in crate_def_map.modules() {

- return Some(crate_def_map.module_id(local_id));

- AssocItemId, DefWithBodyId, HasModule, LocalModuleId, Lookup, ModuleDefId, SyntheticSyntax,

- visit_module(&db, def_map, module.local_id, &mut |it| {

- defs.push((def, module.krate()))

- visit_module(&db, def_map, module.local_id, &mut |it| {

- defs.push((def, module.krate()))

- module_id: LocalModuleId,

- ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it.local_id, cb),

- visit_module(&db, crate_def_map, module.local_id, &mut |def| {

- visit_module(&db, crate_def_map, module.local_id, &mut |def| {

- visit_module(&db, def_map, module.local_id, &mut |it| defs.push(it));

- .display_test(db, DisplayTarget::from_crate(db, module.krate()))

- visit_module(&db, crate_def_map, module.local_id, &mut |def| {

- visit_module(&db, crate_def_map, module.local_id, &mut |def| {

- visit_module(&db, crate_def_map, module.local_id, &mut |def| {

- visit_module(&db, crate_def_map, module.local_id, &mut |def| {

- TraitImpls::for_crate(&db, module.krate());

- TraitImpls::for_crate(&db, module.krate());

- TraitImpls::for_crate(&db, module.krate());

- TraitImpls::for_crate(&db, module.krate());

- TraitImpls::for_crate(&db, module.krate());

- TraitImpls::for_crate(&db, module.krate());

- TraitImpls::for_crate(&db, module.krate());

- TraitImpls::for_crate(&db, module.krate());

- visit_module(&db, crate_def_map, module.local_id, &mut |it| {

- visit_module(&db, crate_def_map, module.local_id, &mut |it| {

- TyKind::Adt(adt_def, _) => adt_def.def_id().0.module(db).krate() == def_map.krate(),

- .is_some_and(|trait_id| trait_id.0.module(db).krate() == def_map.krate()),

- let local_crate = impl_.lookup(db).container.krate();

- if is_local(trait_id.module(db).krate()) {

- TyKind::Adt(adt_def, _) => is_local(adt_def.def_id().0.module(db).krate()),

- it.principal_def_id().is_some_and(|trait_id| is_local(trait_id.0.module(db).krate()))

- crate::tests::visit_module(&db, def_map, module.local_id, &mut |it| {

- AssocItemId, AttrDefId, FieldId, InternedModuleId, LifetimeParamId, ModuleDefId,

- TypeOrConstParamId,

- fn attr_id(self, db: &dyn HirDatabase) -> AttrsOwner {

- AttrsOwner::AttrDef(AttrDefId::ModuleId(InternedModuleId::new(db, self.id)))

- self.root_module().attr_id(db)

- let it = it.loc(db);

- def_map[self.id.local_id].definition_source(db)

- def_map[self.id.local_id].definition_source_range(db)

- def_map[self.id.local_id].definition_source_file_id()

- match def_map[self.id.local_id].origin {

- match def_map[self.id.local_id].origin {

- def_map[self.id.local_id].origin.is_inline()

- def_map[self.id.local_id].declaration_source(db)

- def_map[self.id.local_id].declaration_source_range(db)

- AdtId, AssocItemId, AssocItemLoc, CallableDefId, ConstId, ConstParamId, CrateRootModuleId,

- DefWithBodyId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, GenericDefId,

- GenericParamId, HasModule, ImplId, InternedModuleId, ItemContainerId, LifetimeParamId,

- LocalFieldId, Lookup, MacroExpander, MacroId, StaticId, StructId, SyntheticSyntax, TupleId,

- TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,

- PathResolution, PathResolutionPerNs, Semantics, SemanticsImpl, SemanticsScope, TypeInfo,

- VisibleTraits,

- pub fn root_module(self) -> Module {

- Module { id: CrateRootModuleId::from(self.id).into() }

- def_map.modules().map(|(id, _)| def_map.module_id(id).into()).collect()

- Some(module) => module.krate(),

- pub fn krate(self) -> Crate {

- Crate { id: self.id.krate() }

- let def_map = crate_def_map(db, self.id.krate());

- Module { id: def_map.crate_root().into() }

- pub fn is_crate_root(self) -> bool {

- DefMap::ROOT == self.id.local_id

- let children = def_map[self.id.local_id]

- .map(|module_id| Module { id: def_map.module_id(*module_id) })

- let parent_id = def_map.containing_module(self.id.local_id)?;

- while id.is_block_module() {

- Module { id }

- self.id.def_map(db)[self.id.local_id]

- let edition = self.id.krate().data(db).edition;

- if diag.in_module != self.id.local_id {

- if !self.id.is_block_module() {

- let scope = &def_map[self.id.local_id].scope;

- if def_map[m.id.local_id].origin.is_inline() {

- let interner = DbInterner::new_with(db, self.id.krate());

- emit_def_diagnostic(db, acc, diag, edition, loc.container.krate());

- let scope = &def_map[self.id.local_id].scope;

- let scope = &def_map[self.id.local_id].scope;

- def_map[self.id.local_id].scope.impls().map(Impl::from).collect()

- AttrFlags::doc_keyword(db, InternedModuleId::new(db, self.id))

- let module_data = &def_map[self.id.local_id];

- self.id.lookup(db).container.krate(),

- Ok(body) => body.pretty_print(db, self.module(db).krate().to_display_target(db)),

- let krate = self.module(db).id.krate();

- Module { id: def_map.module_id(DefMap::ROOT) }.diagnostics(db, acc, style_lints);

- || self.module(db).is_crate_root() && db.function_signature(self.id).name == sym::main

- krate: self.id.module(db).krate(),

- let krate = loc.container.krate();

- ItemInNs::Types(did) | ItemInNs::Values(did) => did.module(db).map(|m| m.krate()),

- ItemInNs::Macros(id) => Some(id.module(db).krate()),

- module.id.def_map(db)[module.id.local_id].scope.impls().map(Into::into).collect()

- module.krate(),

- module.containing_block(),

- std::iter::successors(module.containing_block(), |block| {

- block.loc(db).module.containing_block()

- })

- .filter_map(|block| TraitImpls::for_block(db, block).as_deref())

- .for_each(|impls| impls.for_self_ty(&simplified_ty, &mut extend_with_impls));

- for krate in module.krate().transitive_rev_deps(db) {

- if let Some(block) = module.containing_block()

- crate_def_map(db, module_id.krate())[module_id.local_id]

- module.krate(),

- module.containing_block(),

- let interner = DbInterner::new_with(db, module.krate());

- ScopeDef::ModuleDef(it) => it.module(db).map(|m| m.krate()),

- ScopeDef::GenericParam(it) => Some(it.module(db).krate()),

- ScopeDef::AdtSelfType(it) => Some(it.module(db).krate()),

- ScopeDef::Local(it) => Some(it.module(db).krate()),

- ScopeDef::Label(it) => Some(it.module(db).krate()),

- self.module(db).krate().into()

- self.module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- self.parent_def(db).module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- self.module(db).krate()

- fn krate(&self, _: &dyn HirDatabase) -> Crate {

- Module::krate(*self)

- match def_map[self.id.local_id].parent {

- Some(parent_id) => ItemContainer::Module(Module { id: def_map.module_id(parent_id) }),

- let mut module = &def_map[DefMap::ROOT];

- module = &def_map[res.local_id];

- AstNode, AstToken, Direction, SyntaxKind, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange,

- TextSize,

- Some(module) => Some(module.krate()),

- let krate = self.file_to_module_defs(file).next()?.krate();

- let def_map = crate_def_map(self.db, module.krate().id);

- match def_map[module.id.local_id].origin {

- let definition = def_map[module.id.local_id].origin.definition_source(self.db);

- self.file_to_module_defs(file_id.file_id(self.db)).next()?.krate().id

- nameres::DefMap,

- let module_data = &def_map[self.local_id];

- def_map[DefMap::ROOT].scope.child_by_source_to(db, res, file_id);

- res[keys::BLOCK].insert(block.lookup(db).ast_id.to_ptr(db), block);

- let modules = |file| {

- crate_def_map

- .modules_for_file(self.db, file)

- .map(|local_id| crate_def_map.module_id(local_id))

- };

- let &child_id = def_map[parent_module.local_id].children.get(&child_name)?;

- Some(def_map.module_id(child_id))

- let scope = &def_map[module_id.local_id].scope;

- self.work.push(SymbolCollectorWork {

- module_id: def_map.module_id(id),

- parent: name.clone(),

- });

- let module_data = &def_map[module_id.local_id];

- let tuple_ty = Type::new_tuple(module.krate().into(), &tys);

- if trait_.module(db).krate().origin(db).is_local() {

- let is_non_exhaustive = enum_def.is_non_exhaustive(ctx.db(), module.krate());

- let has_hidden_variants =

- variants.iter().any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));

- variant.should_be_hidden(ctx.db(), module.krate()),

- let option_enum = FamousDefs(&ctx.sema, module.krate()).core_option_Option();

- let is_non_exhaustive =

- enum_defs.iter().any(|enum_def| enum_def.is_non_exhaustive(ctx.db(), module.krate()));

- .any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));

- .any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));

- let is_non_exhaustive = enum_def.is_non_exhaustive(ctx.db(), module.krate());

- let has_hidden_variants =

- variants.iter().any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));

- .any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));

- var.attrs(db).is_doc_hidden() && var.module(db).krate() != krate

- e.attrs(db).is_non_exhaustive() && e.module(db).krate() != krate

- let edition = module.krate().edition(db);

- let krate = module.krate();

- let edition = current_module.map(|it| it.krate().edition(ctx.db())).unwrap_or(Edition::CURRENT);

- let crate_boundary_cost = if current.krate() == item.krate() {

- } else if item.krate().origin(db).is_local() {

- } else if item.krate().is_builtin(db) {

- let edition = target_module.krate().edition(ctx.db());

- let cfg =

- ctx.config.find_path_config(ctx.sema.is_nightly(target_module.krate()));

- let krate = module.krate();

- != FamousDefs(&ctx.sema, module.krate()).core_convert_From()?

- if trait_ != FamousDefs(&ctx.sema, module.krate()).core_convert_Into()? {

- let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));

- module.krate().edition(ctx.db()),

- let krate = module.krate();

- let krate = module.krate();

- let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(ref_module.krate()));

- mod_path_to_ast(&mod_path, target_module.krate().edition(ctx.db())),

- let cfg = ctx.config.find_path_config(ctx.sema.is_nightly(module.krate()));