//! This module provides a MIR interpreter, which is used in const eval.

use chalk_ir::{

fold::{FallibleTypeFolder, TypeFoldable, TypeSuperFoldable},

};

use hir_def::{

builtin_type::BuiltinType,

lang_item::{lang_attr, LangItem},

layout::{TagEncoding, Variants},

};

use intern::Interned;

use la_arena::ArenaMap;

use crate::{

consteval::{intern_const_scalar, ConstEvalError},

db::HirDatabase,

from_placeholder_idx,

infer::{normalize, PointerCast},

layout::{layout_of_ty, Layout, LayoutError, RustcEnumVariantIdx},

mapping::from_chalk,

traits::FnTrait,

CallableDefId, ClosureId, Const, ConstScalar, FnDefId, GenericArgData, Interner, MemoryMap,

};

use super::{

const_as_usize, return_slot, AggregateKind, BinOp, CastKind, LocalId, MirBody, MirLowerError,

};

macro_rules! from_bytes {

($ty:tt, $value:expr) => {

($ty::from_le_bytes(match ($value).try_into() {

};

}

id_to_ty: Vec<Ty>,

}

trait_env: Arc<TraitEnvironment>,

stack: Vec<u8>,

heap: Vec<u8>,

/// We don't really have function pointers, i.e. pointers to some assembly instructions that we can run. Instead, we

/// store the type as an interned id in place of function and vtable pointers, and we recover back the type at the

/// time of use.

stack_depth_limit: usize,

}

enum Address {

Stack(usize),

Heap(usize),

Owned(Vec<u8>),

Borrowed(Interval),

}

impl IntervalOrOwned {

pub(crate) fn to_vec(self, memory: &Evaluator<'_>) -> Result<Vec<u8>> {

Ok(match self {

IntervalOrOwned::Borrowed(b) => b.get(memory)?.to_vec(),

})

}

}

impl Address {

#[derive(Clone, PartialEq, Eq)]

pub enum MirEvalError {

LayoutError(LayoutError, Ty),

/// Means that code had type errors (or mismatched args) and we shouldn't generate mir in first place.

TypeError(&'static str),

/// Means that code had undefined behavior. We don't try to actively detect UB, but if it was detected

/// then use this type of error.

Panic(String),

MirLowerError(FunctionId, MirLowerError),

MirLowerErrorForClosure(ClosureId, MirLowerError),

TypeIsUnsized(Ty, &'static str),

NotSupported(String),

InvalidConst(Const),

ExecutionLimitExceeded,

StackOverflow,

TargetDataLayoutNotAvailable,

InvalidVTableId(usize),

}

impl std::fmt::Debug for MirEvalError {

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

match self {

Self::LayoutError(arg0, arg1) => {

f.debug_tuple("LayoutError").field(arg0).field(arg1).finish()

}

Self::TypeIsUnsized(ty, it) => write!(f, "{ty:?} is unsized. {it} should be sized."),

Self::ExecutionLimitExceeded => write!(f, "execution limit exceeded"),

Self::StackOverflow => write!(f, "stack overflow"),

Self::MirLowerError(arg0, arg1) => {

f.debug_tuple("MirLowerError").field(arg0).field(arg1).finish()

}

Self::MirLowerErrorForClosure(arg0, arg1) => {

f.debug_tuple("MirLowerError").field(arg0).field(arg1).finish()

}

Self::InvalidVTableId(arg0) => f.debug_tuple("InvalidVTableId").field(arg0).finish(),

Self::NotSupported(arg0) => f.debug_tuple("NotSupported").field(arg0).finish(),

Self::InvalidConst(arg0) => {

let data = &arg0.data(Interner);

f.debug_struct("InvalidConst").field("ty", &data.ty).field("value", &arg0).finish()

}

let mut e = &**e;

e = &next_e;

}

f.debug_struct("WithStack").field("error", e).field("stack", &stack).finish()

}

}

}

type Result<T> = std::result::Result<T, MirEvalError>;

struct Locals<'a> {

ptr: &'a ArenaMap<LocalId, Address>,

body: &'a MirBody,

) -> Result<Const> {

let ty = body.locals[return_slot()].ty.clone();

let mut evaluator = Evaluator::new(db, body, assert_placeholder_ty_is_unused);

let bytes = evaluator.interpret_mir(&body, None.into_iter(), subst.clone())?;

&bytes,

&ty,

&Locals { ptr: &ArenaMap::new(), body: &body, subst: &subst },

)?;

return Ok(intern_const_scalar(ConstScalar::Bytes(bytes, memory_map), ty));

}

stack: vec![0],

heap: vec![0],

vtable_map: VTableMap::default(),

db,

trait_env,

crate_id,

let mut metadata = None; // locals are always sized

for proj in &p.projection {

let prev_ty = ty.clone();

let (def, _) = self.db.lookup_intern_closure(c.into());

let infer = self.db.infer(def);

let (captures, _) = infer.closure_info(&c);

});

match proj {

ProjectionElem::Deref => {

Some(Interval { addr: addr.offset(self.ptr_size()), size: self.ptr_size() })

} else {

None

.map_err(|e| MirEvalError::LayoutError(e, ty.clone()))

}

fn layout_adt(&self, adt: AdtId, subst: Substitution) -> Result<Layout> {

self.db.layout_of_adt(adt, subst.clone()).map_err(|e| {

MirEvalError::LayoutError(e, TyKind::Adt(chalk_ir::AdtId(adt), subst).intern(Interner))

Ok(match o {

Operand::Copy(p) | Operand::Move(p) => self.place_ty(p, locals)?,

Operand::Constant(c) => c.data(Interner).ty.clone(),

})

}

let Some(terminator) = current_block.terminator.as_ref() else {

not_supported!("block without terminator");

};

current_block_idx = *target;

}

func,

args,

destination,

match &fn_ty.data(Interner).kind {

TyKind::Function(_) => {

let bytes = self.eval_operand(func, &locals)?;

}

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

}

x => not_supported!("unknown function type {x:?}"),

}

current_block_idx = target.expect("broken mir, function without target");

}

let val = u128::from_le_bytes(pad16(

self.eval_operand(discr, &locals)?.get(&self)?,

false,

));

current_block_idx = targets.target_for_value(val);

}

let ty = body.locals[return_slot()].ty.clone();

self.stack_depth_limit += 1;

return Ok(self

)?

.to_owned());

}

}

_ => not_supported!("unknown terminator"),

}

};

match layout.variants {

Variants::Single { index } => {

parent: enum_id,

local_id: index.0,

})?;

Owned(r.to_le_bytes().to_vec())

}

let Some(target_data_layout) = self.db.target_data_layout(self.crate_id) else {

not_supported!("missing target data layout");

};

}

TagEncoding::Niche { untagged_variant, niche_start, .. } => {

let tag = &bytes[offset..offset + size];

Owned(result.to_le_bytes().to_vec())

}

}

}

Rvalue::Repeat(_, _) => not_supported!("evaluating repeat rvalue"),

Rvalue::ShallowInitBox(_, _) => not_supported!("shallow init box"),

Rvalue::CopyForDeref(_) => not_supported!("copy for deref"),

Rvalue::Aggregate(kind, values) => {

let values = values

Owned(r)

}

AggregateKind::Tuple(ty) => {

Owned(self.make_by_layout(

layout.size.bytes_usize(),

&layout,

None,

)?)

}

AggregateKind::Union(x, f) => {

size,

&variant_layout,

tag,

)?)

}

AggregateKind::Closure(ty) => {

Owned(self.make_by_layout(

layout.size.bytes_usize(),

&layout,

None,

)?)

}

}

}

Rvalue::Cast(kind, operand, target_ty) => match kind {

CastKind::Pointer(cast) => match cast {

let current_ty = self.operand_ty(operand, locals)?;

let id = self.vtable_map.id(current_ty);

let ptr_size = self.ptr_size();

Owned(id.to_le_bytes()[0..ptr_size].to_vec())

} else {

}

}

PointerCast::Unsize => {

let current_ty = self.operand_ty(operand, locals)?;

}

x => not_supported!("pointer cast {x:?}"),

},

})

}

fn layout_of_variant(

&mut self,

x: VariantId,

if AdtId::from(f.parent) == 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

return Ok((16, self.layout(&TyBuilder::unit())?, Some((0, 16, i))));

}

}

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

};

let rustc_enum_variant_idx = RustcEnumVariantIdx(enum_variant_id.local_id);

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

let have_tag = match tag_encoding {

TagEncoding::Direct => true,

TagEncoding::Niche { untagged_variant, niche_variants: _, niche_start } => {

}

};

(

size: usize, // Not necessarily equal to variant_layout.size

variant_layout: &Layout,

tag: Option<(usize, usize, i128)>,

) -> Result<Vec<u8>> {

let mut result = vec![0; size];

if let Some((offset, size, value)) = tag {

fn eval_operand(&mut self, x: &Operand, locals: &Locals<'_>) -> Result<Interval> {

Ok(match x {

Operand::Copy(p) | Operand::Move(p) => self.eval_place(p, locals)?,

Operand::Constant(konst) => {

let data = &konst.data(Interner);

match &data.value {

not_supported!("inference var constant")

}

chalk_ir::ConstValue::Placeholder(_) => not_supported!("placeholder constant"),

}

}

})

}

fn eval_place(&mut self, p: &Place, locals: &Locals<'_>) -> Result<Interval> {

let addr = self.place_addr(p, locals)?;

Ok(Interval::new(

let (mem, pos) = match addr {

Stack(x) => (&self.stack, x),

Heap(x) => (&self.heap, x),

}

};

}

fn write_memory(&mut self, addr: Address, r: &[u8]) -> Result<()> {

let (mem, pos) = match addr {

Stack(x) => (&mut self.stack, x),

Heap(x) => (&mut self.heap, x),

}

};

mem.get_mut(pos..pos + r.len())

.copy_from_slice(r);

Ok(())

}

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

if let Some((adt, _)) = ty.as_adt() {

if AdtId::from(f.parent) == 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

}

}

}

if self.assert_placeholder_ty_is_unused {

if matches!(layout, Err(MirEvalError::LayoutError(LayoutError::HasPlaceholder, _))) {

}

}

let layout = layout?;

}

/// A version of `self.size_of` which returns error if the type is unsized. `what` argument should

/// be something that complete this: `error: type {ty} was unsized. {what} should be sized`

fn size_of_sized(&self, ty: &Ty, locals: &Locals<'_>, what: &'static str) -> Result<usize> {

None => Err(MirEvalError::TypeIsUnsized(ty.clone(), what)),

}

}

struct Filler<'a> {

db: &'a dyn HirDatabase,

subst: &'a Substitution,

}

impl FallibleTypeFolder<Interner> for Filler<'_> {

type Error = MirEvalError;

match impl_trait_id {

crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {

let infer = self.db.infer(func.into());

filler.try_fold_ty(infer.type_of_rpit[idx].clone(), outer_binder)

}

crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {

_outer_binder: DebruijnIndex,

) -> std::result::Result<Ty, Self::Error> {

let x = from_placeholder_idx(self.db, idx);

Ok(self

.subst

.as_slice(Interner)

.and_then(|x| x.ty(Interner))

.clone())

}

}

}

let pos = self.heap.len();

Address::Heap(pos)

}

self.interpret_mir(&body, vec![].into_iter(), Substitution::empty(Interner))

}

fn detect_fn_trait(&self, def: FunctionId) -> Option<FnTrait> {

use LangItem::*;

let ItemContainerId::TraitId(parent) = self.db.lookup_intern_function(def).container else {

let mut mm = MemoryMap::default();

match ty.kind(Interner) {

TyKind::Ref(_, _, t) => {

match size {

let addr_usize = from_bytes!(usize, bytes);

mm.insert(

addr_usize,

fn patch_addresses(

&mut self,

patch_map: &HashMap<usize, usize>,

addr: Address,

ty: &Ty,

locals: &Locals<'_>,

) -> Result<()> {

// FIXME: support indirect references

let my_size = self.size_of_sized(ty, locals, "value to patch address")?;

match ty.kind(Interner) {

TyKind::Ref(_, _, t) => {

match size {

Some(_) => {

let current = from_bytes!(usize, self.read_memory(addr, my_size)?);

}

}

}

}

}

}

}

fn exec_fn_pointer(

destination: Interval,

args: &[IntervalAndTy],

locals: &Locals<'_>,

) -> Result<()> {

let id = from_bytes!(usize, bytes.get(self)?);

let next_ty = self.vtable_map.ty(id)?.clone();

}

Ok(())

}

generic_args: &Substitution,

destination: Interval,

args: &[IntervalAndTy],

) -> Result<()> {

let mir_body = self

.db

let arg_bytes = iter::once(Ok(closure_data.get(self)?.to_owned()))

.chain(args.iter().map(|x| Ok(x.get(&self)?.to_owned())))

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

destination.write_from_bytes(self, &bytes)

}

destination: Interval,

args: &[IntervalAndTy],

locals: &Locals<'_>,

) -> Result<()> {

let def: CallableDefId = from_chalk(self.db, def);

let generic_args = self.subst_filler(generic_args, &locals);

match def {

CallableDefId::FunctionId(def) => {

if let Some(_) = self.detect_fn_trait(def) {

return Ok(());

}

}

CallableDefId::StructId(id) => {

let (size, variant_layout, tag) =

size,

&variant_layout,

tag,

)?;

destination.write_from_bytes(self, &result)?;

}

size,

&variant_layout,

tag,

)?;

destination.write_from_bytes(self, &result)?;

}

generic_args: Substitution,

locals: &Locals<'_>,

destination: Interval,

) -> Result<()> {

}

let arg_bytes =

args.iter().map(|x| Ok(x.get(&self)?.to_owned())).collect::<Result<Vec<_>>>()?;

Interner,

generic_args.iter(Interner).enumerate().map(|(i, x)| {

if i == self_ty_idx {

}

}),

);

destination.write_from_bytes(self, &result)?;

Ok(())

}

args: &[IntervalAndTy],

destination: Interval,

locals: &Locals<'_>,

) -> Result<()> {

let func = args.get(0).ok_or(MirEvalError::TypeError("fn trait with no arg"))?;

let mut func_ty = func.ty.clone();

}

match &func_ty.data(Interner).kind {

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

}

TyKind::Function(_) => {

}

TyKind::Closure(closure, subst) => {

}

x => not_supported!("Call FnTrait methods with type {x:?}"),

}

Ok(())

}

}

}

}

}