use base_db::{CrateDisplayName, CrateOrigin, LangCrateOrigin};

use either::Either;

use hir_def::{

attrs::AttrFlags,

expr_store::{ExpressionStoreDiagnostics, ExpressionStoreSourceMap},

hir::{

diagnostics::*,

has_source::HasSource,

semantics::{

},

};

.flatten()

}

}

pub fn modules(self, db: &dyn HirDatabase) -> Vec<Module> {

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

}

pub fn root_file(self, db: &dyn HirDatabase) -> FileId {

impl HasCrate for ModuleDef {

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

match self.module(db) {

None => Crate::core(db).unwrap_or_else(|| db.all_crates()[0].into()),

}

}

}

/// Returns the crate this module is part of.

}

/// Topmost parent of this module. Every module has a `crate_root`, but some

/// might be missing `krate`. This can happen if a module's file is not included

/// in the module tree of any target in `Cargo.toml`.

pub fn crate_root(self, db: &dyn HirDatabase) -> Module {

}

}

/// Iterates over all child modules.

pub fn children(self, db: &dyn HirDatabase) -> impl Iterator<Item = Module> {

let def_map = self.id.def_map(db);

.children

.values()

.collect::<Vec<_>>();

children.into_iter()

}

/// Finds a parent module.

pub fn parent(self, db: &dyn HirDatabase) -> Option<Module> {

let def_map = self.id.def_map(db);

Some(Module { id: parent_id })

}

/// Finds nearest non-block ancestor `Module` (`self` included).

pub fn nearest_non_block_module(self, db: &dyn HirDatabase) -> Module {

let mut id = self.id;

id = id.containing_module(db).expect("block without parent module");

}

}

pub fn path_to_root(self, db: &dyn HirDatabase) -> Vec<Module> {

db: &dyn HirDatabase,

visible_from: Option<Module>,

) -> Vec<(Name, ScopeDef)> {

.scope

.entries()

.filter_map(|(name, def)| {

style_lints: bool,

) {

let _p = tracing::info_span!("diagnostics", name = ?self.name(db)).entered();

let def_map = self.id.def_map(db);

for diag in def_map.diagnostics() {

// FIXME: This is accidentally quadratic.

continue;

}

emit_def_diagnostic(db, acc, diag, edition, def_map.krate());

}

// These are reported by the body of block modules

scope.all_macro_calls().for_each(|it| macro_call_diagnostics(db, it, acc));

}

match def {

ModuleDef::Module(m) => {

// Only add diagnostics from inline modules

m.diagnostics(db, acc, style_lints)

}

acc.extend(def.diagnostics(db, style_lints))

}

self.legacy_macros(db).into_iter().for_each(|m| emit_macro_def_diagnostics(db, acc, m));

let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());

let mut impl_assoc_items_scratch = vec![];

let ast_id_map = db.ast_id_map(file_id);

for diag in impl_def.id.impl_items_with_diagnostics(db).1.iter() {

}

if impl_signature.target_trait.is_none()

pub fn declarations(self, db: &dyn HirDatabase) -> Vec<ModuleDef> {

let def_map = self.id.def_map(db);

scope

.declarations()

.map(ModuleDef::from)

pub fn legacy_macros(self, db: &dyn HirDatabase) -> Vec<Macro> {

let def_map = self.id.def_map(db);

scope.legacy_macros().flat_map(|(_, it)| it).map(|&it| it.into()).collect()

}

pub fn impl_defs(self, db: &dyn HirDatabase) -> Vec<Impl> {

let def_map = self.id.def_map(db);

}

/// Finds a path that can be used to refer to the given item from within

#[inline]

pub fn doc_keyword(self, db: &dyn HirDatabase) -> Option<Symbol> {

}

/// Whether it has `#[path = "..."]` attribute.

impl HasVisibility for Module {

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

let def_map = self.id.def_map(db);

module_data.visibility

}

}

pub fn variant_body_ty<'db>(self, db: &'db dyn HirDatabase) -> Type<'db> {

let interner = DbInterner::new_no_crate(db);

Type::new_for_crate(

match EnumSignature::variant_body_type(db, self.id) {

layout::IntegerType::Pointer(sign) => match sign {

true => Ty::new_int(interner, rustc_type_ir::IntTy::Isize),

pub fn debug_mir(self, db: &dyn HirDatabase) -> String {

let body = db.mir_body(self.id());

match body {

Err(e) => format!("error:\n{e:?}"),

}

}

acc: &mut Vec<AnyDiagnostic<'db>>,

style_lints: bool,

) {

let (body, source_map) = db.body_with_source_map(self.into());

let sig_source_map = match self {

};

for (_, def_map) in body.blocks(db) {

}

expr_store_diagnostics(db, acc, &source_map);

/// is this a `fn main` or a function with an `export_name` of `main`?

pub fn is_main(self, db: &dyn HirDatabase) -> bool {

self.exported_main(db)

}

/// Is this a function with an `export_name` of `main`?

GenericArgs::new_from_iter(interner, []),

ParamEnvAndCrate {

param_env: db.trait_environment(self.id.into()),

},

)?;

let (result, output) = interpret_mir(db, body, false, None)?;

pub fn resolved_crate(self, db: &dyn HirDatabase) -> Option<Crate> {

let loc = self.id.lookup(db);

let name = self.name(db);

if name == sym::self_ {

Some(krate.into())

/// Returns the crate defining this item (or `None` if `self` is built-in).

pub fn krate(&self, db: &dyn HirDatabase) -> Option<Crate> {

match self {

}

}

}

pub fn all_in_module(db: &dyn HirDatabase, module: Module) -> Vec<Impl> {

}

/// **Note:** This is an **approximation** that strives to give the *human-perceived notion* of an "impl for type",

if let Some(module) = method_resolution::simplified_type_module(db, &simplified_ty) {

InherentImpls::for_each_crate_and_block(

db,

&mut |impls| extend_with_impls(impls.for_self_ty(&simplified_ty)),

);

for &krate in &**db.all_crates() {

TraitImpls::for_crate(db, krate)

.for_self_ty(&simplified_ty, &mut extend_with_impls);

let mut handle_impls = |impls: &TraitImpls| {

impls.for_trait(trait_.id, |impls| all.extend(impls.iter().copied().map(Impl::from)));

};

handle_impls(TraitImpls::for_crate(db, krate));

}

&& let Some(impls) = TraitImpls::for_block(db, block)

{

handle_impls(impls);

MacroCallKind::Derive { ast_id, derive_attr_index, derive_index, .. } => {

let module_id = self.id.lookup(db).container;

(

.scope

.derive_macro_invoc(ast_id, derive_attr_index)?,

derive_index,

if let Some(module) = method_resolution::simplified_type_module(db, &simplified_type) {

InherentImpls::for_each_crate_and_block(

db,

&mut |impls| {

handle_impls(impls.for_self_ty(&simplified_type));

},

f: impl FnOnce(&MethodResolutionContext<'_, 'db>) -> R,

) -> R {

let module = resolver.module();

let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);

let unstable_features =

MethodResolutionUnstableFeatures::from_def_map(resolver.top_level_def_map());

pub fn krate(&self, db: &dyn HirDatabase) -> Option<Crate> {

match self {

ScopeDef::ImplSelfType(_) => None,

ScopeDef::Unknown => None,

}

}

impl<T: hir_def::HasModule> HasCrate for T {

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

}

}

impl HasCrate for AssocItem {

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

}

}

impl HasCrate for Struct {

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

}

}

impl HasCrate for Union {

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

}

}

impl HasCrate for Enum {

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

}

}

impl HasCrate for Field {

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

}

}

impl HasCrate for Variant {

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

}

}

impl HasCrate for Function {

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

}

}

impl HasCrate for Const {

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

}

}

impl HasCrate for TypeAlias {

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

}

}

impl HasCrate for Macro {

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

}

}

impl HasCrate for Trait {

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

}

}

impl HasCrate for Static {

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

}

}

impl HasCrate for Adt {

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

}

}

impl HasCrate for Impl {

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

}

}

impl HasCrate for Module {

}

}

fn container(&self, db: &dyn HirDatabase) -> ItemContainer {

// FIXME: handle block expressions as modules (their parent is in a different DefMap)

let def_map = self.id.def_map(db);

None => ItemContainer::Crate(def_map.krate().into()),

}

}

.filter_map(|&krate| {

let segments = segments.clone();

let mut def_map = crate_def_map(db, krate);

let mut segments = segments.with_position().peekable();

while let Some((_, segment)) = segments.next_if(|&(position, _)| {

!matches!(position, itertools::Position::Last | itertools::Position::Only)

_ => None,

})?;

def_map = res.def_map(db);

}

let (_, item_name) = segments.next()?;

let res = module.scope.get(&Name::new_symbol_root(item_name));