mem,

};

use chalk_ir::{BoundVar, Safety, TyKind};

use either::Either;

use hir_def::{

db::DefDatabase,

find_path::{self, PrefixKind},

item_scope::ItemInNs,

lang_item::{LangItem, LangItemTarget},

nameres::DefMap,

type_ref::{

},

visibility::Visibility,

};

use itertools::Itertools;

use la_arena::ArenaMap;

use rustc_apfloat::{

Float,

};

use rustc_hash::FxHashSet;

use smallvec::SmallVec;

use triomphe::Arc;

use crate::{

consteval::try_const_usize,

db::{HirDatabase, InternedClosure},

from_assoc_type_id, from_foreign_def_id, from_placeholder_idx,

mapping::from_chalk,

mir::pad16,

primitive, to_assoc_type_id,

};

pub trait HirWrite: fmt::Write {

}

impl HirFormatter<'_> {

self.display_target.krate

}

#[derive(Debug, Clone, Copy)]

pub struct DisplayTarget {

pub edition: Edition,

}

impl DisplayTarget {

Self { krate, edition }

}

}

Err(HirDisplayError::FmtError) => Err(fmt::Error),

Err(HirDisplayError::DisplaySourceCodeError(_)) => {

// This should never happen

}

}

}

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

write!(

f,

">::{}",

.name

)?;

hir_fmt_generics(f, proj_params, None, None)

}

}

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

Ok(())

}

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

};

match adt.0 {

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

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

render_variant_after_name(

f,

&field_types,

f.db.trait_environment(adt.0.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>");

};

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

render_variant_after_name(

f,

&field_types,

f.db.trait_environment(adt.0.into()),

}

fn render_variant_after_name(

f: &mut HirFormatter<'_>,

field_types: &ArenaMap<LocalFieldId, Binders<Ty>>,

trait_env: Arc<TraitEnvironment>,

b: &[u8],

memory_map: &MemoryMap,

) -> Result<(), HirDisplayError> {

let render_field = |f: &mut HirFormatter<'_>, id: LocalFieldId| {

let offset = layout.fields.offset(u32::from(id.into_raw()) as usize).bytes_usize();

let ty = field_types[id].clone().substitute(Interner, subst);

let size = layout.size.bytes_usize();

render_const_scalar(f, &b[offset..offset + size], memory_map, &ty)

};

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

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

render_field(f, id)?;

}

for (id, data) in it {

render_field(f, id)?;

}

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

}

Ok(())

}

}

}

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::StructId(s) => {

}

};

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

// Normally, functions cannot have default parameters, but they can,

// for function-like things such as struct names or enum variants.

} else {

};

write!(f, "<")?;

hir_fmt_generic_arguments(f, parent_params, None)?;

if !parent_params.is_empty() && !fn_params.is_empty() {

write!(f, ", ")?;

}

write!(f, ">")?;

}

}

TyKind::Adt(AdtId(def_id), parameters) => {

f.start_location_link((*def_id).into());

match f.display_kind {

let name = match *def_id {

};

}

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

}

TyKind::Foreign(type_alias) => {

let alias = from_foreign_def_id(*type_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| {

});

write!(f, "impl ")?;

if let Some(t) = future_trait {

match f.closure_style {

ClosureStyle::Hide => return write!(f, "{TYPE_HINT_TRUNCATION}"),

ClosureStyle::ClosureWithId => {

}

ClosureStyle::ClosureWithSubst => {

write!(f, "{{closure#{:?}}}", id.0.as_u32())?;

}

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

Some(default_parameter) => {

// !is_err(default_parameter.skip_binders())

// &&

}

}

};

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

pub enum SizedByDefault {

NotSized,

}

impl SizedByDefault {

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

}

if let AliasTy::Projection(proj) = alias {

let assoc_ty_id = from_assoc_type_id(proj.associated_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(

f,

None,

)?;

write!(f, ">")?;

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 ...) ")

}

}

fn hir_fmt(

&self,

f: &mut HirFormatter<'_>,

) -> Result<(), HirDisplayError>;

}

fn hir_fmt(

&self,

f: &mut HirFormatter<'_>,

) -> Result<(), HirDisplayError> {

}

}

value: T,

) -> impl HirDisplay + 'a {

}

}

}

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

T::hir_fmt(&self.0, f, self.1)

}

}

fn hir_fmt(

&self,

f: &mut HirFormatter<'_>,

) -> Result<(), HirDisplayError> {

TypeRef::Never => write!(f, "!")?,

TypeRef::Placeholder => write!(f, "_")?,

TypeRef::Tuple(elems) => {

write!(f, "(")?;

if elems.len() == 1 {

write!(f, ",")?;

}

write!(f, ")")?;

}

TypeRef::RawPtr(inner, mutability) => {

let mutability = match mutability {

hir_def::type_ref::Mutability::Shared => "*const ",

hir_def::type_ref::Mutability::Mut => "*mut ",

};

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

}

TypeRef::Reference(ref_) => {

let mutability = match ref_.mutability {

};

write!(f, "&")?;

if let Some(lifetime) = &ref_.lifetime {

}

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

}

TypeRef::Array(array) => {

write!(f, "[")?;

}

TypeRef::Slice(inner) => {

write!(f, "[")?;

write!(f, "]")?;

}

TypeRef::Fn(fn_) => {

write!(f, "unsafe ")?;

}

f.write_str("extern \"")?;

f.write_str(abi.as_str())?;

f.write_str("\" ")?;

}

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

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

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

if let Some(name) = param_name {

}

if index != function_parameters.len() - 1 {

write!(f, ", ")?;

}

}

}

write!(f, ")")?;

TypeRef::Tuple(tup) if tup.is_empty() => {}

_ => {

write!(f, " -> ")?;

}

}

}

}

TypeRef::ImplTrait(bounds) => {

write!(f, "impl ")?;

}

TypeRef::DynTrait(bounds) => {

write!(f, "dyn ")?;

}

TypeRef::Error => write!(f, "{{error}}")?,

}

}

}

fn hir_fmt(

&self,

f: &mut HirFormatter<'_>,

) -> Result<(), HirDisplayError> {

match self {

&TypeBound::Path(path, modifier) => {

TraitBoundModifier::None => (),

TraitBoundModifier::Maybe => write!(f, "?")?,

}

}

TypeBound::ForLifetime(lifetimes, path) => {

let edition = f.edition();

write!(

f,

"for<{}> ",

)?;

}

TypeBound::Use(args) => {

let edition = f.edition();

}

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

}

}

}

fn hir_fmt(

&self,

f: &mut HirFormatter<'_>,

) -> Result<(), HirDisplayError> {

match (self.type_anchor(), self.kind()) {

(Some(anchor), _) => {

write!(f, "<")?;

write!(f, ">")?;

}

(_, PathKind::Plain) => {}

// Resolve `$crate` to the crate's display name.

// FIXME: should use the dependency name instead if available, but that depends on

// the crate invoking `HirDisplay`

.display_name

.as_ref()

write!(f, "{name}")?

}

}

});

if let Some(ty) = trait_self_ty {

write!(f, "<")?;

write!(f, " as ")?;

// Now format the path of the trait...

}

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?

_ => None,

}

}

}

}

}

}

}

}

}

}

fn hir_fmt(

&self,

f: &mut HirFormatter<'_>,

) -> Result<(), HirDisplayError> {

match self {

}

}

}

}