use std::{borrow::Cow, cell::RefCell, fmt::Write, iter, mem, ops::Range};

use either::Either;

use hir_def::{

builtin_type::BuiltinType,

expr_store::HygieneId,

lang_item::LangItem,

layout::{TagEncoding, Variants},

resolver::{HasResolver, TypeNs, ValueNs},

};

use intern::sym;

use la_arena::ArenaMap;

use rustc_abi::TargetDataLayout;

use rustc_apfloat::{

Float,

};

use rustc_hash::{FxHashMap, FxHashSet};

use span::FileId;

use triomphe::Arc;

use crate::{

db::{HirDatabase, InternedClosure},

display::{ClosureStyle, DisplayTarget, HirDisplay},

infer::PointerCast,

method_resolution::{is_dyn_method, lookup_impl_const},

static_lifetime,

traits::FnTrait,

};

use super::{

};

mod shim;

cached_fn_trait_func: Option<FunctionId>,

cached_fn_mut_trait_func: Option<FunctionId>,

cached_fn_once_trait_func: Option<FunctionId>,

// FIXME: This is a workaround, see the comment on `interpret_mir`

assert_placeholder_ty_is_unused: bool,

/// A general limit on execution, to prevent non terminating programs from breaking r-a main process

for (func, span, def) in stack.iter().take(30).rev() {

match func {

Either::Left(func) => {

writeln!(

f,

"In function {} ({:?})",

func

)?;

}

},

MirSpan::Unknown => continue,

};

let text_range = span.value.text_range();

}

}

match err {

)?;

}

MirEvalError::MirLowerError(func, err) => {

ItemContainerId::ImplId(impl_id) => Some({

let substs = generics.placeholder_subst(db);

db.impl_self_ty(impl_id)

.substitute(Interner, &substs)

.to_string()

}),

ItemContainerId::TraitId(it) => Some(

),

_ => None,

};

"MIR lowering for function `{}{}{}` ({:?}) failed due:",

self_.as_deref().unwrap_or_default(),

if self_.is_some() { "::" } else { "" },

func

)?;

err.pretty_print(f, db, span_formatter, display_target)?;

assert_placeholder_ty_is_unused: bool,

trait_env: Option<Arc<TraitEnvironment>>,

) -> Result<Evaluator<'_>> {

let target_data_layout = match db.target_data_layout(crate_id) {

Ok(target_data_layout) => target_data_layout,

Err(e) => return Err(MirEvalError::TargetDataLayoutNotAvailable(e)),

cached_fn_trait_func: db

.lang_item(crate_id, LangItem::Fn)

.and_then(|x| x.as_trait())

cached_fn_mut_trait_func: db

.lang_item(crate_id, LangItem::FnMut)

.and_then(|x| x.as_trait())

.and_then(|x| {

}),

cached_fn_once_trait_func: db

.lang_item(crate_id, LangItem::FnOnce)

.and_then(|x| x.as_trait())

.and_then(|x| {

}),

})

}

Variants::Multiple { variants, .. } => {

&variants[match f.parent {

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

}

_ => {

return Err(MirEvalError::InternalError(

"mismatched layout".into(),

}

}]

}

"Stack overflow. Tried to grow stack to {stack_size} bytes"

)));

}

Ok((locals, prev_stack_pointer))

}

match &layout.variants {

Variants::Empty => unreachable!(),

Variants::Single { index } => {

Ok(r)

}

Variants::Multiple { tag, tag_encoding, variants, .. } => {

.unwrap_or(*untagged_variant)

.0;

let result =

Ok(result)

}

}

AdtId::EnumId(_) => not_supported!("unsizing enums"),

};

let Some((last_field, _)) =

else {

not_supported!("unsizing struct without field");

};

subst: Substitution,

locals: &Locals,

) -> Result<(usize, Arc<Layout>, Option<(usize, usize, i128)>)> {

if let DefWithBodyId::VariantId(f) = locals.body.owner {

if let VariantId::EnumVariantId(it) = it {

if let AdtId::EnumId(e) = adt {

// Computing the exact size of enums require resolving the enum discriminants. In order to prevent loops (and

// infinite sized type errors) we use a dummy layout

let i = self.const_eval_discriminant(it)?;

_ => not_supported!("multi variant layout for non-enums"),

};

let mut discriminant = self.const_eval_discriminant(enum_variant_id)?;

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

let variant_layout = variants[rustc_enum_variant_idx].clone();

let have_tag = match tag_encoding {

"encoded tag ({offset}, {size}, {value}) is out of bounds 0..{size}"

)

.into(),

}

}

}

None => {

return Err(MirEvalError::InternalError(

format!("field offset ({offset}) is out of bounds 0..{size}").into(),

}

}

}

.db

.const_eval(const_id, subst, Some(self.trait_env.clone()))

.map_err(|e| {

MirEvalError::ConstEvalError(name, Box::new(e))

})?;

if let chalk_ir::ConstValue::Concrete(c) = &result_owner.data(Interner).value {

_ => {

return Err(MirEvalError::UndefinedBehavior(format!(

"invalid memory write at address {addr:?}"

}

}

}

if let DefWithBodyId::VariantId(f) = locals.body.owner {

if let Some((AdtId::EnumId(e), _)) = ty.as_adt() {

// Computing the exact size of enums require resolving the enum discriminants. In order to prevent loops (and

// infinite sized type errors) we use a dummy size

return Ok(Some((16, 16)));

return Err(MirEvalError::Panic(format!("Memory allocation of {size} bytes failed")));

}

let pos = self.heap.len();

Ok(Address::Heap(pos))

}

}

chalk_ir::TyKind::Adt(adt, subst) => match adt.0 {

AdtId::StructId(s) => {

let layout = this.layout(ty)?;

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

let offset = layout

.fields

.offset(u32::from(f.into_raw()) as usize)

bytes,

e,

) {

let field_types = this.db.field_types(v.into());

for (f, _) in data.fields().iter() {

let offset =

let mir_body = self

.db

.monomorphized_mir_body_for_closure(

generic_args.clone(),

self.trait_env.clone(),

)

} else {

let (imp, generic_args) =

self.db.lookup_impl_method(self.trait_env.clone(), def, generic_args.clone());

let mir_body = self

.db

.monomorphized_mir_body(imp.into(), generic_args, self.trait_env.clone())

let ty = ty.clone().cast(Interner);

let generics_for_target = Substitution::from_iter(

Interner,

);

self.exec_fn_with_args(

def,

if let Some(o) = self.static_locations.get(&st) {

return Ok(*o);

};

let konst = self.db.const_eval_static(st).map_err(|e| {

MirEvalError::ConstEvalError(static_data.name.as_str().to_owned(), Box::new(e))

})?;

match r {

Ok(r) => Ok(r),

Err(e) => {

let loc = variant.lookup(db);

let enum_loc = loc.parent.lookup(db);

let name = format!(

"{}::{}",

);

Err(MirEvalError::ConstEvalError(name, Box::new(e)))

}

) -> Result<()> {

let Some(drop_fn) = (|| {

let drop_trait = self.db.lang_item(self.crate_id, LangItem::Drop)?.as_trait()?;

})() else {

// in some tests we don't have drop trait in minicore, and

// we can ignore drop in them.

TyKind::Adt(id, subst) => {

match id.0 {

AdtId::StructId(s) => {

if data.flags.contains(StructFlags::IS_MANUALLY_DROP) {

return Ok(());

}

let layout = self.layout_adt(id.0, subst.clone())?;

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

let offset = layout

.fields

.offset(u32::from(field.into_raw()) as usize)

self.run_drop_glue_deep(ty, locals, addr, &[], span)?;

}

}

}

}

AdtId::UnionId(_) => (), // union fields don't need drop

drop_flags: DropFlags::default(),

};

let data = evaluator.allocate_const_in_heap(locals, c)?;

let Some(TypeNs::TraitId(debug_trait)) = resolver.resolve_path_in_type_ns_fully(

) else {

not_supported!("core::fmt::Debug not found");

};

let Some(debug_fmt_fn) =

else {

not_supported!("core::fmt::Debug::fmt not found");

};

evaluator.write_memory(a3.offset(2 * evaluator.ptr_size()), &a2.to_bytes())?;

evaluator.write_memory(a3.offset(3 * evaluator.ptr_size()), &[1])?;

let Some(ValueNs::FunctionId(format_fn)) = resolver.resolve_path_in_value_ns_fully(

HygieneId::ROOT,

) else {

not_supported!("std::fmt::format not found");