};

use base_db::Crate;

use either::Either;

use hir_def::{

FindPathConfig, GeneralConstId, GenericDefId, HasModule, LocalFieldId, Lookup, ModuleDefId,

Float,

ieee::{Half as f16, Quad as f128},

};

use rustc_hash::FxHashSet;

use rustc_type_ir::{

};

use smallvec::SmallVec;

use span::Edition;

use stdx::never;

use triomphe::Arc;

use crate::{

generics::generics,

layout::Layout,

mir::pad16,

next_solver::{

},

};

pub trait HirWrite: fmt::Write {

// `core::Formatter` will ignore metadata

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

/// The database handle

/// The sink to write into

fmt: &'a mut dyn HirWrite,

/// A buffer to intercept writes with, this allows us to track the overall size of the formatted output.

display_lifetimes: DisplayLifetime,

display_kind: DisplayKind,

display_target: DisplayTarget,

}

// FIXME: To consider, ref and dyn trait lifetimes can be omitted if they are `'_`, path args should

}

#[derive(Default)]

Entered {

/// We can have recursive bounds like the following case:

/// ```ignore

/// ```

/// So, record the projection types met while formatting bounds and

//. prevent recursing into their bounds to avoid infinite loops.

},

#[default]

Exited,

}

match self {

BoundsFormattingCtx::Entered { projection_tys_met } => {

projection_tys_met.contains(proj)

}

}

fn start_location_link(&mut self, location: ModuleDefId) {

self.fmt.start_location_link(location);

}

fn format_bounds_with<T, F: FnOnce(&mut Self) -> T>(

&mut self,

format_bounds: F,

) -> T {

match self.bounds_formatting_ctx {

}

}

match self.display_lifetimes {

DisplayLifetime::Always => true,

DisplayLifetime::OnlyNamed => {

}

}

DisplayLifetime::Never => false,

}

}

}

/// Returns a `Display`able type that is human-readable.

fn into_displayable<'a>(

&'a self,

max_size: Option<usize>,

limited_size: Option<usize>,

omit_verbose_types: bool,

display_kind: DisplayKind,

closure_style: ClosureStyle,

show_container_bounds: bool,

where

Self: Sized,

{

/// Use this for showing types to the user (e.g. diagnostics)

fn display<'a>(

&'a self,

display_target: DisplayTarget,

where

Self: Sized,

{

/// Use this for showing types to the user where space is constrained (e.g. doc popups)

fn display_truncated<'a>(

&'a self,

max_size: Option<usize>,

display_target: DisplayTarget,

where

Self: Sized,

{

/// Use this for showing definitions which may contain too many items, like `trait`, `struct`, `enum`

fn display_limited<'a>(

&'a self,

limited_size: Option<usize>,

display_target: DisplayTarget,

where

Self: Sized,

{

/// Use this when generating code (e.g. assists)

fn display_source_code<'a>(

&'a self,

module_id: ModuleId,

allow_opaque: bool,

) -> Result<String, DisplaySourceCodeError> {

let mut result = String::new();

match self.hir_fmt(&mut HirFormatter {

db,

fmt: &mut result,

buf: String::with_capacity(20),

curr_size: 0,

/// Returns a String representation of `self` for test purposes

fn display_test<'a>(

&'a self,

display_target: DisplayTarget,

where

Self: Sized,

{

/// the container for functions

fn display_with_container_bounds<'a>(

&'a self,

show_container_bounds: bool,

display_target: DisplayTarget,

where

Self: Sized,

{

}

}

pub fn krate(&self) -> Crate {

self.display_target.krate

}

self.display_target.edition

}

&mut self,

iter: impl IntoIterator<Item = T>,

sep: &str,

}

}

t: &'a T,

max_size: Option<usize>,

limited_size: Option<usize>,

Hide,

}

pub fn write_to<F: HirWrite>(&self, f: &mut F) -> Result<(), HirDisplayError> {

self.t.hir_fmt(&mut HirFormatter {

db: self.db,

fmt: f,

buf: String::with_capacity(self.max_size.unwrap_or(20)),

curr_size: 0,

}

}

where

{

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

match self.write_to(f) {

const TYPE_HINT_TRUNCATION: &str = "…";

HirDisplay::hir_fmt(*self, f)

}

}

HirDisplay::hir_fmt(self.as_ref(), f)

}

}

.filter(|wc| {

};

return false;

};

})

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

}

}

}

}

}

}

match self.kind() {

write!(f, "?{}.{}", db.as_u32(), bound_const.var.as_u32())

}

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

let param_data = &generics[param.id.local_id()];

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

Ok(())

}

f,

&const_bytes.value.inner().memory,

&const_bytes.value.inner().memory_map,

const_bytes.ty,

),

let c = match unev.def {

SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),

SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),

_ => unreachable!(),

};

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

Ok(())

}

}

}

}

b: &[u8],

) -> Result<(), HirDisplayError> {

let trait_env = TraitEnvironment::empty(f.krate());

let ty = infcx.at(&ObligationCause::new(), trait_env.env).deeply_normalize(ty).unwrap_or(ty);

render_const_scalar_inner(f, b, memory_map, ty, trait_env)

}

fn render_const_scalar_inner<'db>(

b: &[u8],

trait_env: Arc<TraitEnvironment<'db>>,

) -> Result<(), HirDisplayError> {

match ty.kind() {

TyKind::Bool => write!(f, "{}", b[0] != 0),

TyKind::Char => {

write!(f, "{it}")

}

TyKind::Float(fl) => match fl {

// FIXME(#17451): Replace with builtins once they are stabilised.

let it = f16::from_bits(u16::from_le_bytes(b.try_into().unwrap()).into());

let s = it.to_string();

write!(f, "{s}")

}

}

let it = f32::from_le_bytes(b.try_into().unwrap());

write!(f, "{it:?}")

}

let it = f64::from_le_bytes(b.try_into().unwrap());

write!(f, "{it:?}")

}

// FIXME(#17451): Replace with builtins once they are stabilised.

let it = f128::from_bits(u128::from_le_bytes(b.try_into().unwrap()));

let s = it.to_string();

f.write_str(", ")?;

}

let offset = size_one * i;

}

f.write_str("]")

}

return f.write_str("<ref-data-not-available>");

};

f.write_str("&")?;

}

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

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

return f.write_str("<ref-data-not-available>");

};

f.write_str("&")?;

}

},

TyKind::Tuple(tys) => {

continue;

};

let size = layout.size.bytes_usize();

}

f.write_str(")")

}

f.write_str(", ")?;

}

let offset = size_one * i;

}

f.write_str("]")

}

fn render_variant_after_name<'db>(

data: &VariantFields,

trait_env: Arc<TraitEnvironment<'db>>,

layout: &Layout,

b: &[u8],

) -> Result<(), HirDisplayError> {

match data.shape {

FieldsShape::Record | FieldsShape::Tuple => {

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

return f.write_str("<layout-error>");

};

let size = layout.size.bytes_usize();

};

let mut it = data.fields().iter();

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

}

}

fn hir_fmt(

&self,

) -> Result<(), HirDisplayError> {

if f.should_truncate() {

return write!(f, "{TYPE_HINT_TRUNCATION}");

}

match self.kind() {

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

TyKind::Str => write!(f, "str")?,

TyKind::Bool => write!(f, "bool")?,

TyKind::Char => write!(f, "char")?,

TyKind::Slice(t) => {

write!(f, "[")?;

t.hir_fmt(f)?;

write!(f, "[")?;

t.hir_fmt(f)?;

write!(f, "; ")?;

write!(f, "]")?;

}

kind @ (TyKind::RawPtr(t, m) | TyKind::Ref(_, t, m)) => {

if let TyKind::Ref(l, _, _) = kind {

f.write_char('&')?;

if f.render_region(l) {

f.write_char(' ')?;

}

match m {

}

// FIXME: all this just to decide whether to use parentheses...

let (preds_to_print, has_impl_fn_pred) = match t.kind() {

TyKind::Dynamic(bounds, region) => {

let render_lifetime = f.render_region(region);

}

TyKind::Alias(AliasTyKind::Opaque, ty) => {

let opaque_ty_id = match ty.def_id {

let datas = db

.return_type_impl_traits(func)

.expect("impl trait id without data");

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

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

let default_sized = SizedByDefault::Sized { anchor: func.krate(db) };

.filter(|b| {

matches!(

if default_sized.is_sized_trait(

db,

),

)

}

}

} else {

(0, false)

}

}

}

TyKind::FnPtr(sig, header) => {

sig.hir_fmt(f)?;

}

TyKind::FnDef(def, args) => {

let def = def.0;

if f.display_kind.is_source_code() {

// `FnDef` is anonymous and there's no surface syntax for it. Show it as a

// function pointer type.

return sig.hir_fmt(f);

}

write!(f, "unsafe ")?;

}

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

f.write_str("\" ")?;

}

write!(f, "fn ")?;

f.start_location_link(def.into());

match def {

};

f.end_location_link();

let generic_def_id = GenericDefId::from_callable(db, def);

let generics = generics(db, generic_def_id);

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

generics.provenance_split();

debug_assert_eq!(

parameters.len(),

parent_len + self_param as usize + type_ + const_ + impl_ + lifetime

}

}

write!(f, "(")?;

write!(f, ")")?;

if !ret.is_unit() {

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

ret.hir_fmt(f)?;

}

f.end_location_link();

}

TyKind::Foreign(alias) => {

let type_alias = db.type_alias_signature(alias.0);

f.start_location_link(alias.0.into());

SolverDefId::InternedOpaqueTyId(id) => id,

_ => unreachable!(),

};

if !f.display_kind.allows_opaque() {

return Err(HirDisplayError::DisplaySourceCodeError(

DisplaySourceCodeError::OpaqueType,

let datas =

db.return_type_impl_traits(func).expect("impl trait id without data");

let data =

let krate = func.krate(db);

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

SizedByDefault::Sized { anchor: krate },

)?;

// FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution

ImplTraitId::TypeAliasImplTrait(alias, idx) => {

let datas =

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

let krate = alias.krate(db);

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

SizedByDefault::Sized { anchor: krate },

)?;

}

}

}

TyKind::Closure(id, substs) => {

let id = id.0;

if f.display_kind.is_source_code() {

if !f.display_kind.allows_opaque() {

return Err(HirDisplayError::DisplaySourceCodeError(

}

ClosureStyle::ClosureWithSubst => {

write!(f, "{{closure#{:?}}}", salsa::plumbing::AsId::as_id(&id).index())?;

}

_ => (),

}

if let Some(sig) = sig {

let InternedClosure(def, _) = db.lookup_intern_closure(id);

let infer = db.infer(def);

let (_, kind) = infer.closure_info(id);

ClosureStyle::RANotation => write!(f, "|")?,

_ => unreachable!(),

}

} else if f.should_truncate() {

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

} else {

};

match f.closure_style {

ClosureStyle::ImplFn => write!(f, ")")?,

ClosureStyle::RANotation => write!(f, "|")?,

_ => unreachable!(),

}

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

}

} else {

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

}

}

TyKind::Placeholder(_) => write!(f, "{{placeholder}}")?,

TyKind::Param(param) => {

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

let param_data = &generics[param.id.local_id()];

match param_data {

)?

}

TypeParamProvenance::ArgumentImplTrait => {

let bounds = db

.generic_predicates(param.id.parent())

})

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

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

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

&bounds,

SizedByDefault::Sized { anchor: krate },

)?;

}

}

}

}

write_bounds_like_dyn_trait_with_prefix(

f,

"dyn",

SizedByDefault::NotSized,

)?;

}

}

}

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

let CoroutineArgsParts { resume_ty, yield_ty, return_ty, .. } =

subst.split_coroutine_args();

}

TyKind::CoroutineWitness(..) => write!(f, "{{coroutine witness}}")?,

TyKind::Pat(_, _) => write!(f, "{{pat}}")?,

TyKind::UnsafeBinder(_) => write!(f, "{{unsafe binder}}")?,

TyKind::Alias(_, _) => write!(f, "{{alias}}")?,

}

Ok(())

}

}

generic_def: Option<hir_def::GenericDefId>,

) -> Result<(), HirDisplayError> {

if parameters.is_empty() {

return Ok(());

Ok(())

}

generic_def: Option<hir_def::GenericDefId>,

if f.display_kind.is_source_code() || f.omit_verbose_types() {

None => parameters,

Some(default_parameters) => {

}

};

let mut default_from = 0;

if should_show(parameter, i) {

default_from = i + 1;

}

}

fn hir_fmt_generic_args<'db>(

generic_def: Option<hir_def::GenericDefId>,

) -> Result<(), HirDisplayError> {

if parameters.is_empty() {

return Ok(());

}

if !parameters_to_write.is_empty() {

write!(f, "<")?;

write!(f, ">")?;

}

Ok(())

}

) -> Result<(), HirDisplayError> {

let mut first = true;

let (ty_or_const, lifetimes) = match lifetime_offset {

Some(offset) => parameters.split_at(offset),

write!(f, ", ")?;

}

match self_ {

_ => generic_arg.hir_fmt(f)?,

}

}

Ok(())

}

) -> Result<(), HirDisplayError> {

let mut first = true;

if !mem::take(&mut first) {

write!(f, ", ")?;

}

match self_ {

}

}

Ok(())

}

if let Safety::Unsafe = safety {

write!(f, "unsafe ")?;

}

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

// }

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

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

} else {

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

}

}

write!(f, ")")?;

if !ret.is_unit() {

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

ret.hir_fmt(f)?;

}

}

fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = TraitId> + '_ {

let krate = trait_.lookup(db).container.krate();

utils::fn_traits(db, krate)

}

}

prefix: &str,

default_sized: SizedByDefault,

) -> Result<(), HirDisplayError> {

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

}

}

default_sized: SizedByDefault,

) -> Result<(), HirDisplayError> {

// Note: This code is written to produce nice results (i.e.

let mut angle_open = false;

let mut is_fn_trait = false;

let mut is_sized = false;

if default_sized.is_sized_trait(trait_, f.db) {

is_sized = true;

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

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

f.end_location_link();

if is_fn_trait {

{

write!(f, "(")?;

write!(f, ")")?;

}

} else {

let params = generic_args_sans_defaults(

f,

Some(trait_.into()),

);

&& !params.is_empty()

{

write!(f, "<")?;

// there might be assoc type bindings, so we leave the angle brackets open

angle_open = true;

}

}

}

if !is_fn_trait && angle_open {

write!(f, ">")?;

angle_open = false;

if !first {

write!(f, " + ")?;

}

}

if !is_fn_trait && angle_open {

write!(f, ">")?;

angle_open = false;

if !first {

write!(f, " + ")?;

}

}

is_fn_trait = false;

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

}

}

// in types in actual Rust, these will always come

// after the corresponding Implemented predicate

if angle_open {

write!(f, "<")?;

angle_open = true;

}

}

}

}

first = false;

}

Ok(())

}

let trait_ = self.def_id.0;

f.start_location_link(trait_.into());

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

f.end_location_link();

let substs = self.args.as_slice();

}

}

match self.kind() {

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

let param_data = &generics[param.id.local_id];

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

Ok(())

}

write!(f, "?{}.{}", db.as_u32(), idx.var.as_u32())

}

if cfg!(test) {

write!(f, "'?")

} else {

write!(f, "'_")

}

}

}

}

}

module_id: ModuleId,

vis: Visibility,

) -> Result<(), HirDisplayError> {

match vis {

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

}

}

fn hir_fmt(

&self,

store: &ExpressionStore,

) -> Result<(), HirDisplayError>;

}

fn hir_fmt(

&self,

store: &ExpressionStore,

) -> Result<(), HirDisplayError> {

T::hir_fmt(&**self, f, store)

}

}

value: T,

store: &'a ExpressionStore,

ExpressionStoreAdapter(value, store)

}

}

}

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

}

}

fn hir_fmt(

&self,

store: &ExpressionStore,

) -> Result<(), HirDisplayError> {

match &store[*self] {

}

}

fn hir_fmt(

&self,

store: &ExpressionStore,

) -> Result<(), HirDisplayError> {

match &store[*self] {

}

}

fn hir_fmt(

&self,

_store: &ExpressionStore,

) -> Result<(), HirDisplayError> {

// FIXME

}

}

fn hir_fmt(

&self,

store: &ExpressionStore,

) -> Result<(), HirDisplayError> {

match self {

}

}

fn hir_fmt(

&self,

store: &ExpressionStore,

) -> Result<(), HirDisplayError> {

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

}

}

fn hir_fmt(

&self,

store: &ExpressionStore,

) -> Result<(), HirDisplayError> {

match self {