use base_db::CrateId;

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

use hir_def::{

data::adt::VariantData,

db::DefDatabase,

use itertools::Itertools;

use la_arena::ArenaMap;

use smallvec::SmallVec;

use triomphe::Arc;

use crate::{

mir::pad16,

primitive, to_assoc_type_id,

utils::{self, detect_variant_from_bytes, generics, ClosureSubst},

};

pub trait HirWrite: fmt::Write {

impl HirWrite for fmt::Formatter<'_> {}

pub struct HirFormatter<'a> {

pub db: &'a dyn HirDatabase,

fmt: &'a mut dyn HirWrite,

buf: String,

curr_size: usize,

pub entity_limit: Option<usize>,

omit_verbose_types: bool,

closure_style: ClosureStyle,

#[derive(Debug)]

pub enum DisplaySourceCodeError {

PathNotFound,

Coroutine,

OpaqueType,

}

let proj_params_count =

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

let proj_params = &self.substitution.as_slice(Interner)[..proj_params_count];

}

}

ConstValue::Placeholder(idx) => {

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

let generics = generics(f.db.upcast(), id.parent);

write!(f, "{}", param_data.name().unwrap().display(f.db.upcast()))?;

Ok(())

}

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

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

write!(f, "{}", c.name(f.db.upcast()))?;

Ok(())

}

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

}

};

f.end_location_link();

if parameters.len(Interner) > 0 {

let generics = generics(db.upcast(), def.into());

// We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self?

// `parameters` are in the order of fn's params (including impl traits), fn's lifetimes

// parent's params (those from enclosing impl or trait, if any).

write!(f, "<")?;

write!(f, ">")?;

}

}

let generic_def = self.as_generic_def(db);

}

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

let type_alias = from_assoc_type_id(*assoc_type_id);

f.end_location_link();

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

// trait (including the self type).

} else {

let projection_ty = ProjectionTy {

associated_ty_id: to_assoc_type_id(type_alias),

substitution: parameters.clone(),

};

}

TyKind::Foreign(type_alias) => {

let alias = from_foreign_def_id(*type_alias);

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

bounds.skip_binders(),

SizedByDefault::Sized { anchor: krate },

)?;

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

bounds.skip_binders(),

SizedByDefault::Sized { anchor: krate },

)?;

}

ClosureStyle::ClosureWithSubst => {

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

}

_ => (),

}

TyKind::Placeholder(idx) => {

let id = from_placeholder_idx(db, *idx);

let generics = generics(db.upcast(), id.parent);

match param_data {

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

TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => {

.generic_predicates(id.parent)

.iter()

.map(|pred| pred.clone().substitute(Interner, &substs))

WhereClause::Implemented(tr) => {

}

WhereClause::AliasEq(AliasEq {

alias: AliasTy::Projection(proj),

ty: _,

})

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

let krate = id.parent.module(db.upcast()).krate();

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

&bounds,

SizedByDefault::Sized { anchor: krate },

)?;

write_bounds_like_dyn_trait_with_prefix(

f,

"dyn",

&bounds,

SizedByDefault::NotSized,

)?;

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

bounds.skip_binders(),

SizedByDefault::Sized { anchor: krate },

)?;

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

bounds.skip_binders(),

SizedByDefault::Sized { anchor: krate },

)?;

}

TyKind::Error => {

if f.display_target.is_source_code() {

}

}

TyKind::InferenceVar(..) => write!(f, "_")?,

TyKind::Coroutine(_, subst) => {

fn hir_fmt_generics(

f: &mut HirFormatter<'_>,

generic_def: Option<hir_def::GenericDefId>,

) -> Result<(), HirDisplayError> {

}

}

}

}

}

}

}

Ok(())

}

pub fn write_bounds_like_dyn_trait_with_prefix(

f: &mut HirFormatter<'_>,

prefix: &str,

predicates: &[QuantifiedWhereClause],

default_sized: SizedByDefault,

) -> Result<(), HirDisplayError> {

|| predicates.is_empty() && matches!(default_sized, SizedByDefault::Sized { .. })

{

write!(f, " ")?;

} else {

Ok(())

}

fn write_bounds_like_dyn_trait(

f: &mut HirFormatter<'_>,

predicates: &[QuantifiedWhereClause],

default_sized: SizedByDefault,

) -> Result<(), HirDisplayError> {

f.start_location_link(trait_.into());

write!(f, "{}", f.db.trait_data(trait_).name.display(f.db.upcast()))?;

f.end_location_link();

if let Some(args) =

params.first().and_then(|it| it.assert_ty_ref(Interner).as_tuple())

{

write!(f, "(")?;

write!(f, ")")?;

}

}

}

}

WhereClause::AliasEq(alias_eq) if is_fn_trait => {

is_fn_trait = false;

if !alias_eq.ty.is_unit() {

let proj_arg_count = generics(f.db.upcast(), assoc_ty_id.into()).len_self();

if proj_arg_count > 0 {

write!(f, "<")?;

&proj.substitution.as_slice(Interner)[..proj_arg_count],

)?;

write!(f, ">")?;

}

}

ty.hir_fmt(f)?;

}

}

first = false;

}

f.start_location_link(trait_.into());

write!(f, "{}", f.db.trait_data(trait_).name.display(f.db.upcast()))?;

f.end_location_link();

}

impl HirDisplay for TraitRef {

impl HirDisplay for LifetimeData {

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

match self {

LifetimeData::Placeholder(idx) => {

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

let generics = generics(f.db.upcast(), id.parent);

write!(f, "{}", param_data.name.display(f.db.upcast()))?;

Ok(())

}

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

LifetimeData::Erased => Ok(()),

LifetimeData::Phantom(_, _) => Ok(()),

}