segments.extend(m.name(db))

}

segments.reverse();

}

pub fn canonical_module_path(

impl Module {

/// Name of this module.

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

}

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

/// Iterates over all child modules.

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

let children = def_map[self.id.local_id]

.children

.values()

/// Finds a parent module.

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

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

Some(Module { id: parent_id })

}

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

let mut id = self.id;

while id.is_block_module() {

}

Module { id }

}

db: &dyn HirDatabase,

visible_from: Option<Module>,

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

.scope

.entries()

.filter_map(|(name, def)| {

if let Some(m) = visible_from {

if filtered.is_none() && !def.is_none() { None } else { Some((name, filtered)) }

} else {

Some((name, def))

db: &dyn HirDatabase,

segments: impl IntoIterator<Item = Name>,

) -> Option<impl Iterator<Item = ItemInNs>> {

Some(items.iter_items().map(|(item, _)| item.into()))

}

) {

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

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

for diag in def_map.diagnostics() {

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

// FIXME: This is accidentally quadratic.

let source_map = db.enum_signature_with_source_map(e.id).1;

expr_store_diagnostics(db, acc, &source_map);

let (variants, diagnostics) = db.enum_variants_with_diagnostics(e.id);

let ast_id_map = db.ast_id_map(file);

if let Some(diagnostics) = &diagnostics {

for diag in diagnostics.iter() {

for impl_def in self.impl_defs(db) {

GenericDef::Impl(impl_def).diagnostics(db, acc);

let source_map = db.impl_signature_with_source_map(impl_def.id).1;

expr_store_diagnostics(db, acc, &source_map);

let node = &tree[loc.id.value];

let file_id = loc.id.file_id();

// these expansion come from us, diagnosing them is a waste of resources

// FIXME: Once we diagnose the inputs to builtin derives, we should at least extract those diagnostics somehow

continue;

}

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

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

scope

.declarations()

}

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

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

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

}

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

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

}

let file_id = loc.kind.file_id();

let node =

InFile::new(file_id, db.ast_id_map(file_id).get_erased(loc.kind.erased_ast_id()));

let precise_location = if err.span().anchor.file_id == file_id {

Some(

err.span().range

never!("declarative expander for non decl-macro: {:?}", e);

return;

};

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

emit_def_diagnostic_(

db,

) {

match diag {

DefDiagnosticKind::UnresolvedModule { ast: declaration, candidates } => {

acc.push(

UnresolvedModule {

decl: InFile::new(declaration.file_id, decl),

)

}

DefDiagnosticKind::UnresolvedExternCrate { ast } => {

acc.push(UnresolvedExternCrate { decl: InFile::new(ast.file_id, item) }.into());

}

DefDiagnosticKind::MacroError { ast, path, err } => {

acc.push(

MacroError {

node: InFile::new(ast.file_id, item.syntax_node_ptr()),

precise_location: None,

error,

kind,

}

}

DefDiagnosticKind::UnresolvedImport { id, index } => {

let file_id = id.file_id();

let import = &item_tree[id.value];

acc.push(

UnresolvedImport { decl: InFile::new(file_id, AstPtr::new(&use_tree)) }.into(),

);

}

DefDiagnosticKind::UnconfiguredCode { tree, item, cfg, opts } => {

let ast_id_map = db.ast_id_map(tree.file_id());

// FIXME: This parses... We could probably store relative ranges for the children things

// here in the item tree?

);

}

DefDiagnosticKind::UnimplementedBuiltinMacro { ast } => {

// Must have a name, otherwise we wouldn't emit it.

let name = node.name().expect("unimplemented builtin macro with no name");

acc.push(

);

}

DefDiagnosticKind::InvalidDeriveTarget { ast, id } => {

let derive = node.attrs().nth(*id);

match derive {

Some(derive) => {

}

}

DefDiagnosticKind::MalformedDerive { ast, id } => {

let derive = node.attrs().nth(*id);

match derive {

Some(derive) => {

}

}

DefDiagnosticKind::MacroDefError { ast, message } => {

acc.push(

MacroDefError {

node: InFile::new(ast.file_id, AstPtr::new(&node)),

// - e.g. the full attribute for macro errors, but only the name for name resolution

match ast {

MacroCallKind::FnLike { ast_id, .. } => {

(

ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node))),

node.path()

)

}

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

// Compute the precise location of the macro name's token in the derive

// list.

let token = (|| {

)

}

MacroCallKind::Attr { ast_id, invoc_attr_index, .. } => {

let attr = collect_attrs(&node)

.nth(invoc_attr_index.ast_index())

.and_then(|x| Either::left(x.1))

impl HasVisibility for Module {

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

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

module_data.visibility

}

let generic_def_id: GenericDefId = match self.parent {

VariantDef::Struct(it) => it.id.into(),

VariantDef::Union(it) => it.id.into(),

};

let substs = TyBuilder::placeholder_subst(db, generic_def_id);

let ty = db.field_types(var_id)[self.id].clone().substitute(Interner, &substs);

self.ty(db).ty,

db.trait_environment(match hir_def::VariantId::from(self.parent) {

hir_def::VariantId::EnumVariantId(id) => {

}

hir_def::VariantId::StructId(id) => GenericDefId::AdtId(id.into()),

hir_def::VariantId::UnionId(id) => GenericDefId::AdtId(id.into()),

let visibility = &variant_data.fields()[self.id].visibility;

let parent_id: hir_def::VariantId = self.parent.into();

// FIXME: RawVisibility::Public doesn't need to construct a resolver

}

}

impl Struct {

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

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

impl HasVisibility for Struct {

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

Visibility::resolve(

&item_tree[item_tree[loc.id.value].visibility],

)

}

}

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

}

pub fn ty(self, db: &dyn HirDatabase) -> Type {

impl HasVisibility for Union {

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

Visibility::resolve(

&item_tree[item_tree[loc.id.value].visibility],

)

}

impl Enum {

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

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

/// The type of the enum variant bodies.

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

Type::new_for_crate(

TyBuilder::builtin(match db.enum_signature(self.id).variant_body_type() {

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

true => hir_def::builtin_type::BuiltinType::Int(

impl HasVisibility for Enum {

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

Visibility::resolve(

&item_tree[item_tree[loc.id.value].visibility],

)

}

impl Variant {

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

}

pub fn parent_enum(self, db: &dyn HirDatabase) -> Enum {

}

pub fn constructor_ty(self, db: &dyn HirDatabase) -> Type {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

let enum_ = lookup.parent;

db.enum_variants(enum_).variants[lookup.index as usize].1.clone()

}

Ok(match &parent_layout.0.variants {

layout::Variants::Multiple { variants, .. } => Layout(

{

let rustc_enum_variant_idx = RustcEnumVariantIdx(lookup.index as usize);

Arc::new(variants[rustc_enum_variant_idx].clone())

},

/// Returns the lifetime of the DataType

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

let resolver = match self {

};

resolver

.generic_params()

/// A textual representation of the HIR of this def's body for debugging purposes.

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

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

}

/// A textual representation of the MIR of this def's body for debugging purposes.

}

};

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

}

InactiveCode { node: *node, cfg: cfg.clone(), opts: opts.clone() }.into()

}

ExpressionStoreDiagnostics::MacroError { node, err } => {

let precise_location = if err.span().anchor.file_id == node.file_id {

Some(

impl Function {

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

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn fn_ptr_type(self, db: &dyn HirDatabase) -> Type {

let substs = TyBuilder::placeholder_subst(db, self.id);

let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

let ty = TyKind::Function(callable_sig.to_fn_ptr()).intern(Interner);

/// Get this function's return type

pub fn ret_type(self, db: &dyn HirDatabase) -> Type {

let substs = TyBuilder::placeholder_subst(db, self.id);

let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

let ty = callable_sig.ret().clone();

db: &dyn HirDatabase,

generics: impl Iterator<Item = Type>,

) -> Type {

ItemContainerId::ImplId(it) => Some(it.into()),

ItemContainerId::TraitId(it) => Some(it.into()),

ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => None,

if !self.is_async(db) {

return None;

}

let substs = TyBuilder::placeholder_subst(db, self.id);

let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);

let ret_ty = callable_sig.ret().clone();

generics: impl Iterator<Item = Type>,

) -> Vec<Param> {

let environment = db.trait_environment(self.id.into());

ItemContainerId::ImplId(it) => Some(it.into()),

ItemContainerId::TraitId(it) => Some(it.into()),

ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => None,

}

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

ItemContainerId::ExternBlockId(id) => Some(ExternBlock { id }),

_ => None,

}

{

return None;

}

def_map.fn_as_proc_macro(self.id).map(|id| Macro { id: id.into() })

}

// FIXME: Find better API to also handle const generics

pub fn ty_with_args(&self, db: &dyn HirDatabase, generics: impl Iterator<Item = Type>) -> Type {

ItemContainerId::ImplId(it) => it.into(),

ItemContainerId::TraitId(it) => it.into(),

ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => {

impl ExternCrateDecl {

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

}

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

let krate = loc.container.krate();

let name = &item_tree[loc.id.value].name;

if *name == sym::self_ {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

item_tree[loc.id.value].name.clone()

}

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

item_tree[loc.id.value].alias.clone()

}

/// Returns the name under which this crate is made accessible, taking `_` into account.

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

match &item_tree[loc.id.value].alias {

Some(ImportAlias::Underscore) => None,

impl HasVisibility for ExternCrateDecl {

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

Visibility::resolve(

&item_tree[item_tree[loc.id.value].visibility],

)

}

impl Const {

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

}

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

impl Static {

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

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

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

ItemContainerId::ExternBlockId(id) => Some(ExternBlock { id }),

_ => None,

}

impl HasVisibility for Static {

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

Visibility::resolve(

&item_tree[item_tree[loc.id.value].visibility],

)

}

}

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

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

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

traits.iter().map(|tr| Trait::from(*tr)).collect()

}

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

traits.iter().map(|tr| Trait::from(*tr)).collect()

}

impl HasVisibility for Trait {

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

Visibility::resolve(

&item_tree[item_tree[loc.id.value].visibility],

)

}

impl TraitAlias {

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

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

impl HasVisibility for TraitAlias {

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

Visibility::resolve(

&item_tree[item_tree[loc.id.value].visibility],

)

}

}

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

}

pub fn ty(self, db: &dyn HirDatabase) -> Type {

impl ExternBlock {

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

}

}

impl Macro {

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

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

match self.id {

MacroId::Macro2Id(id) => {

item_tree[loc.id.value].name.clone()

}

MacroId::MacroRulesId(id) => {

item_tree[loc.id.value].name.clone()

}

MacroId::ProcMacroId(id) => {

match loc.kind {

ProcMacroKind::CustomDerive => db

.attrs(id.into())

pub fn kind(&self, db: &dyn HirDatabase) -> MacroKind {

match self.id {

MacroExpander::Declarative => MacroKind::Declarative,

MacroExpander::BuiltIn(_) | MacroExpander::BuiltInEager(_) => {

MacroKind::DeclarativeBuiltIn

MacroExpander::BuiltInAttr(_) => MacroKind::AttrBuiltIn,

MacroExpander::BuiltInDerive(_) => MacroKind::DeriveBuiltIn,

},

MacroExpander::Declarative => MacroKind::Declarative,

MacroExpander::BuiltIn(_) | MacroExpander::BuiltInEager(_) => {

MacroKind::DeclarativeBuiltIn

MacroExpander::BuiltInAttr(_) => MacroKind::AttrBuiltIn,

MacroExpander::BuiltInDerive(_) => MacroKind::DeriveBuiltIn,

},

ProcMacroKind::CustomDerive => MacroKind::Derive,

ProcMacroKind::Bang => MacroKind::ProcMacro,

ProcMacroKind::Attr => MacroKind::Attr,

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

match self.id {

MacroId::Macro2Id(it) => {

}

MacroId::MacroRulesId(it) => {

}

MacroId::ProcMacroId(_) => false,

}

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

match self.id {

MacroId::Macro2Id(it) => {

}

MacroId::MacroRulesId(it) => {

}

MacroId::ProcMacroId(_) => false,

}

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

match self.id {

MacroId::Macro2Id(it) => {

}

MacroId::MacroRulesId(it) => {

}

MacroId::ProcMacroId(_) => false,

}

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

match self.id {

MacroId::Macro2Id(id) => {

Visibility::resolve(

&item_tree[item_tree[loc.id.value].visibility],

)

}

DEF: From<ID>,

LOC: ItemTreeNode,

{

ItemContainerId::TraitId(_) | ItemContainerId::ImplId(_) => Some(ctor(DEF::from(id))),

ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => None,

}

DEF: From<ID>,

LOC: ItemTreeNode,

{

ItemContainerId::ExternBlockId(_) => Some(ctor(DEF::from(id))),

ItemContainerId::TraitId(_) | ItemContainerId::ImplId(_) | ItemContainerId::ModuleId(_) => {

None

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

let container = match self {

};

match container {

ItemContainerId::TraitId(id) => AssocItemContainer::Trait(id.into()),

pub fn types(&self, db: &dyn HirDatabase) -> Vec<(Symbol, Type)> {

let container = match self.def {

_ => None,

};

let container_type_params = container

}

pub fn original_file(&self, db: &dyn HirDatabase) -> EditionedFileId {

}

pub fn file(&self) -> HirFileId {

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

match body.self_param.zip(source_map.self_param_syntax()) {

Some((param, source)) if param == self.binding_id => {

vec![LocalSource {

local: self,

source: source.map(|ast| Either::Right(ast.to_node(&root))),

.iter()

.map(|&definition| {

let src = source_map.pat_syntax(definition).unwrap(); // Hmm...

LocalSource {

local: self,

source: src.map(|ast| match ast.to_node(&root) {

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

match body.self_param.zip(source_map.self_param_syntax()) {

Some((param, source)) if param == self.binding_id => {

LocalSource {

local: self,

source: source.map(|ast| Either::Right(ast.to_node(&root))),

.first()

.map(|&definition| {

let src = source_map.pat_syntax(definition).unwrap(); // Hmm...

LocalSource {

local: self,

source: src.map(|ast| match ast.to_node(&root) {

GenericParam::ConstParam(_) => return None,

GenericParam::LifetimeParam(it) => it.id.parent,

};

let index = match self {

GenericParam::TypeParam(it) => generics.type_or_const_param_idx(it.id.into())?,

GenericParam::ConstParam(_) => return None,

}

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

}

/// Is this type parameter implicitly introduced (eg. `Self` in a trait or an `impl Trait`

}

pub fn ty(self, db: &dyn HirDatabase) -> Type {

let ty =

TyKind::Placeholder(hir_ty::to_placeholder_idx(db, self.id.into())).intern(Interner);

Type::new_with_resolver_inner(db, &resolver, ty)

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

let ty = generic_arg_from_param(db, self.id.into())?;

match ty.data(Interner) {

GenericArgData::Ty(it) if *it.kind(Interner) != TyKind::Error => {

Some(Type::new_with_resolver_inner(db, &resolver, it.clone()))

}

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

}

pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {

}

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

}

pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {

}

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

}

pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {

}

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

}

pub fn all_for_type(db: &dyn HirDatabase, Type { ty, env }: Type) -> Vec<Impl> {

);

}

{

if let Some(inherent_impls) = db.inherent_impls_in_block(block) {

all.extend(

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

let substs = TyBuilder::placeholder_subst(db, self.id);

let trait_ref = db.impl_trait(self.id)?.substitute(Interner, &substs);

Some(TraitRef::new_with_resolver(db, &resolver, trait_ref))

}

pub fn self_ty(self, db: &dyn HirDatabase) -> Type {

let substs = TyBuilder::placeholder_subst(db, self.id);

let ty = db.impl_self_ty(self.id).substitute(Interner, &substs);

Type::new_with_resolver_inner(db, &resolver, ty)

}

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

}

pub fn as_builtin_derive_path(self, db: &dyn HirDatabase) -> Option<InMacroFile<ast::Path>> {

let src = self.source(db)?;

let macro_file = src.file_id.macro_file()?;

let (derive_attr, derive_index) = match loc.kind {

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

(

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

.scope

}

fn new(db: &dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty) -> Type {

let environment = resolver

.generic_def()

.map_or_else(|| TraitEnvironment::empty(resolver.krate()), |d| db.trait_environment(d));

ValueTyDefId::StructId(it) => GenericDefId::AdtId(AdtId::StructId(it)),

ValueTyDefId::UnionId(it) => GenericDefId::AdtId(AdtId::UnionId(it)),

ValueTyDefId::EnumVariantId(it) => {

}

ValueTyDefId::StaticId(_) => return Type::new(db, def, ty.skip_binders().clone()),

},

alias: TypeAlias,

) -> Option<Type> {

let mut args = args.iter();

ItemContainerId::TraitId(id) => id,

_ => unreachable!("non assoc type alias reached in normalize_trait_assoc_type()"),

};

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

self.autoderef_(db)

.filter_map(|ty| ty.dyn_trait())

.map(Trait::from)

}

.flat_map(|ty| {

self.env

.traits_in_scope_from_clauses(ty)

})

.map(Trait::from)

}

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

fn is_visible_from(&self, db: &dyn HirDatabase, module: Module) -> bool {

let vis = self.visibility(db);

}

}

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

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

}

}

impl HasContainer for ExternCrateDecl {

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

}

}

impl HasContainer for Module {

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

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

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

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

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

impl HasContainer for Function {

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

}

}

impl HasContainer for Struct {

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

}

}

impl HasContainer for Union {

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

}

}

impl HasContainer for Enum {

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

}

}

impl HasContainer for TypeAlias {

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

}

}

impl HasContainer for Const {

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

}

}

impl HasContainer for Static {

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

}

}

impl HasContainer for Trait {

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

}

}

impl HasContainer for TraitAlias {

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

}

}

impl HasContainer for ExternBlock {

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

}

}

ModuleDefId::ModuleId(it) => Some(it),

_ => None,

})?;

module = &def_map[res.local_id];

}

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