if !f.bounds_formatting_ctx.contains(self) {

let db = f.db;

let id = from_placeholder_idx(db, *idx);

let substs = generics.placeholder_subst(db);

let bounds = db

">::{}",

f.db.type_alias_signature(from_assoc_type_id(self.associated_ty_id))

.name

)?;

let proj_params_count =

self.substitution.len(Interner) - trait_ref.substitution.len(Interner);

ConstValue::InferenceVar(..) => write!(f, "#c#"),

ConstValue::Placeholder(idx) => {

let id = from_placeholder_idx(f.db, *idx);

let param_data = &generics[id.local_id];

Ok(())

}

ConstValue::Concrete(c) => match &c.interned {

ConstScalar::Bytes(b, m) => render_const_scalar(f, b, m, &data.ty),

ConstScalar::UnevaluatedConst(c, parameters) => {

Ok(())

}

ConstScalar::Unknown => f.write_char('_'),

TyKind::Adt(adt, _) if b.len() == 2 * size_of::<usize>() => match adt.0 {

hir_def::AdtId::StructId(s) => {

let data = f.db.struct_signature(s);

Ok(())

}

_ => f.write_str("<unsized-enum-or-union>"),

match adt.0 {

hir_def::AdtId::StructId(s) => {

let data = f.db.struct_signature(s);

let field_types = f.db.field_types(s.into());

render_variant_after_name(

&f.db.variant_fields(s.into()),

)

}

hir_def::AdtId::UnionId(u) => {

}

hir_def::AdtId::EnumId(e) => {

let Ok(target_data_layout) = f.db.target_data_layout(trait_env.krate) else {

else {

return f.write_str("<failed-to-detect-variant>");

};

write!(

f,

"{}",

f.db.enum_variants(loc.parent).variants[loc.index as usize]

.1

)?;

let field_types = f.db.field_types(var_id.into());

render_variant_after_name(

if matches!(data.shape, FieldsShape::Record) {

write!(f, " {{")?;

if let Some((id, data)) = it.next() {

render_field(f, id)?;

}

for (id, data) in it {

render_field(f, id)?;

}

write!(f, " }}")?;

bounds.iter().any(|bound| {

if let WhereClause::Implemented(trait_ref) = bound.skip_binders() {

let trait_ = trait_ref.hir_trait_id();

} else {

false

}

// Don't count Sized but count when it absent

// (i.e. when explicit ?Sized bound is set).

let sized_bounds = bounds

.skip_binders()

.iter()

WhereClause::Implemented(trait_ref)

if default_sized.is_sized_trait(

trait_ref.hir_trait_id(),

),

)

})

write!(f, "fn ")?;

f.start_location_link(def.into());

match def {

CallableDefId::EnumVariantId(e) => {

write!(

f,

"{}",

db.enum_variants(loc.parent).variants[loc.index as usize]

.1

)?

}

};

f.end_location_link();

if parameters.len(Interner) > 0 {

let (parent_len, self_param, type_, const_, impl_, lifetime) =

generics.provenance_split();

let parameters = parameters.as_slice(Interner);

hir_def::AdtId::UnionId(it) => db.union_signature(it).name.clone(),

hir_def::AdtId::EnumId(it) => db.enum_signature(it).name.clone(),

};

}

DisplayKind::SourceCode { target_module_id: module_id, allow_opaque: _ } => {

if let Some(path) = find_path::find_path(

ItemInNs::Types((*def_id).into()),

module_id,

PrefixKind::Plain,

allow_unstable: true,

},

) {

} else {

return Err(HirDisplayError::DisplaySourceCodeError(

DisplaySourceCodeError::PathNotFound,

}

TyKind::AssociatedType(assoc_type_id, parameters) => {

let type_alias = from_assoc_type_id(*assoc_type_id);

ItemContainerId::TraitId(it) => it,

_ => panic!("not an associated type"),

};

// Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types)

if f.display_kind.is_test() {

f.start_location_link(trait_.into());

f.end_location_link();

write!(f, "::")?;

f.start_location_link(type_alias.into());

f.end_location_link();

// Note that the generic args for the associated type come before those for the

// trait (including the self type).

let alias = from_foreign_def_id(*type_alias);

let type_alias = db.type_alias_signature(alias);

f.start_location_link(alias.into());

f.end_location_link();

}

TyKind::OpaqueType(opaque_ty_id, parameters) => {

let data =

(*datas).as_ref().map(|rpit| rpit.impl_traits[idx].bounds.clone());

let bounds = data.substitute(Interner, &parameters);

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

db.type_alias_impl_traits(alias).expect("impl trait id without data");

let data = (*datas).as_ref().map(|it| it.impl_traits[idx].bounds.clone());

let bounds = data.substitute(Interner, &parameters);

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

}

ImplTraitId::AsyncBlockTypeImplTrait(body, ..) => {

let future_trait = db

.and_then(LangItemTarget::as_trait);

let output = future_trait.and_then(|t| {

db.trait_items(t).associated_type_by_name(&Name::new_symbol_root(

}

TyKind::Placeholder(idx) => {

let id = from_placeholder_idx(db, *idx);

let param_data = &generics[id.local_id];

match param_data {

TypeOrConstParamData::TypeParamData(p) => match p.provenance {

p.name

.clone()

.unwrap_or_else(Name::missing)

)?

}

TypeParamProvenance::ArgumentImplTrait => {

WhereClause::LifetimeOutlives(_) => false,

})

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

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

}

},

TypeOrConstParamData::ConstParamData(p) => {

}

}

}

let data =

(*datas).as_ref().map(|rpit| rpit.impl_traits[idx].bounds.clone());

let bounds = data.substitute(Interner, &opaque_ty.substitution);

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

let data =

(*datas).as_ref().map(|rpit| rpit.impl_traits[idx].bounds.clone());

let bounds = data.substitute(Interner, &opaque_ty.substitution);

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

match p.skip_binders() {

WhereClause::Implemented(trait_ref) => {

let trait_ = trait_ref.hir_trait_id();

is_sized = true;

if matches!(default_sized, SizedByDefault::Sized { .. }) {

// Don't print +Sized, but rather +?Sized if absent.

}

}

if !is_fn_trait {

}

if !is_fn_trait && angle_open {

write!(f, ">")?;

// existential) here, which is the only thing that's

// possible in actual Rust, and hence don't print it

f.start_location_link(trait_.into());

f.end_location_link();

if is_fn_trait {

if let [self_, params @ ..] = trait_ref.substitution.as_slice(Interner) {

let assoc_ty_id = from_assoc_type_id(proj.associated_ty_id);

let type_alias = f.db.type_alias_signature(assoc_ty_id);

f.start_location_link(assoc_ty_id.into());

f.end_location_link();

if proj_arg_count > 0 {

write!(f, "<")?;

hir_fmt_generic_arguments(

fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {

let trait_ = self.hir_trait_id();

f.start_location_link(trait_.into());

f.end_location_link();

let substs = self.substitution.as_slice(Interner);

hir_fmt_generics(f, &substs[1..], None, substs[0].ty(Interner))

write!(

f,

"{}",

)?;

f.end_location_link();

write!(f, " = ")?;

match self {

LifetimeData::Placeholder(idx) => {

let id = lt_from_placeholder_idx(f.db, *idx);

let param_data = &generics[id.local_id];

Ok(())

}

_ if f.display_kind.is_source_code() => write!(f, "'_"),

match vis {

Visibility::Public => write!(f, "pub "),

Visibility::Module(vis_id, _) => {

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

if vis_id == module_id {

// pub(self) or omitted

Ok(())

} else if root_module_id == vis_id {

write!(f, "pub(crate) ")

write!(f, "pub(super) ")

} else {

write!(f, "pub(in ...) ")

_store: &ExpressionStore,

) -> Result<(), HirDisplayError> {

match self {

LifetimeRef::Static => write!(f, "'static"),

LifetimeRef::Placeholder => write!(f, "'_"),

LifetimeRef::Error => write!(f, "'{{error}}"),

TypeRef::TypeParam(param) => {

let generic_params = f.db.generic_params(param.parent());

match generic_params[param.local_id()].name() {

None => {

write!(f, "impl ")?;

f.write_joined(

for index in 0..function_parameters.len() {

let (param_name, param_type) = &function_parameters[index];

if let Some(name) = param_name {

}

param_type.hir_fmt(f, store)?;

write!(

f,

"for<{}> ",

)?;

store[*path].hir_fmt(f, store)

}

for (idx, arg) in args.iter().enumerate() {

match arg {

UseArgRef::Lifetime(lt) => lt.hir_fmt(f, store)?,

}

if idx != last {

write!(f, ", ")?;

if !matches!(self.kind(), PathKind::Plain) || seg_idx > 0 {

write!(f, "::")?;

}

if let Some(generic_args) = segment.args_and_bindings {

// We should be in type context, so format as `Foo<Bar>` instead of `Foo::<Bar>`.

// Do we actually format expressions?

} else {

write!(f, ", ")?;

}

match &binding.type_ref {

Some(ty) => {

write!(f, " = ")?;

match self {

hir_def::expr_store::path::GenericArg::Type(ty) => ty.hir_fmt(f, store),

hir_def::expr_store::path::GenericArg::Const(_c) => {

write!(f, "<expr>")

}

hir_def::expr_store::path::GenericArg::Lifetime(lifetime) => lifetime.hir_fmt(f, store),