+ lang_item::{self, LangItem, LangItemTarget, LangItems},

+ #[salsa::invoke(lang_item::lang_attr_query)]

+ fn lang_attr(&self, def: AttrDefId) -> Option<LangItem>;

+

+ if let Some(lang_item) = db.lang_attr(item.into()) {

+pub(crate) fn lang_attr_query(db: &dyn DefDatabase, item: AttrDefId) -> Option<LangItem> {

+ let attrs = db.attrs(item);

+ attrs.by_key("lang").string_value().and_then(|it| LangItem::from_str(&it))

+ lang_item::{LangItem, LangItemTarget},

+ let well_known = db.lang_attr(trait_.into()).and_then(well_known_trait_from_lang_item);

+ let c = interpret_mir(db, body, false).0?;

+ let c = interpret_mir(db, body, false).0?;

+ let c = interpret_mir(db, mir_body, false).0?;

+ if let Ok(result) = interpret_mir(db, Arc::new(mir_body), true).0 {

+ ConstEvalError::MirEvalError(MirEvalError::InFunction(e, _)) => {

+ |e| e == ConstEvalError::MirEvalError(MirEvalError::ExecutionLimitExceeded),

+ #[salsa::invoke(crate::method_resolution::lookup_impl_method_query)]

+ fn lookup_impl_method(

+ &self,

+ env: Arc<crate::TraitEnvironment>,

+ func: FunctionId,

+ fn_subst: Substitution,

+ ) -> (FunctionId, Substitution);

+

+ lang_item::LangItem,

+ if let Some(lang) = self.db.lang_attr(tr.hir_trait_id().into()) {

+pub(crate) fn lookup_impl_method_query(

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

+ lang_item::LangItem,

+ method_resolution::is_dyn_method,

+ return_slot, AggregateKind, BasicBlockId, BinOp, CastKind, LocalId, MirBody, MirLowerError,

+ MirSpan, Operand, Place, ProjectionElem, Rvalue, StatementKind, TerminatorKind, UnOp,

+struct StackFrame {

+ body: Arc<MirBody>,

+ locals: Locals,

+ destination: Option<BasicBlockId>,

+ prev_stack_ptr: usize,

+ span: (MirSpan, DefWithBodyId),

+}

+

+ code_stack: Vec<StackFrame>,

+ layout_cache: RefCell<FxHashMap<Ty, Arc<Layout>>>,

+ locals: &Locals,

+ InFunction(Box<MirEvalError>, Vec<(Either<FunctionId, ClosureId>, MirSpan, DefWithBodyId)>),

+ while let MirEvalError::InFunction(e, stack) = err {

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

+ match func {

+ Either::Left(func) => {

+ let function_name = db.function_data(*func);

+ writeln!(

+ f,

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

+ function_name.name.display(db.upcast()),

+ func

+ )?;

+ }

+ Either::Right(clos) => {

+ writeln!(f, "In {:?}", clos)?;

+ }

+ let source_map = db.body_with_source_map(*def).1;

+ let span: InFile<SyntaxNodePtr> = match span {

+ MirSpan::ExprId(e) => match source_map.expr_syntax(*e) {

+ Ok(s) => s.map(|it| it.into()),

+ Err(_) => continue,

+ },

+ MirSpan::PatId(p) => match source_map.pat_syntax(*p) {

+ Ok(s) => s.map(|it| match it {

+ Either::Left(e) => e.into(),

+ Either::Right(e) => e.into(),

+ }),

+ Err(_) => continue,

+ },

+ MirSpan::Unknown => continue,

+ };

+ let file_id = span.file_id.original_file(db.upcast());

+ let text_range = span.value.text_range();

+ writeln!(f, "{}", span_formatter(file_id, text_range))?;

+ Self::InFunction(e, stack) => {

+struct Locals {

+ ptr: ArenaMap<LocalId, Interval>,

+ body: Arc<MirBody>,

+ body: Arc<MirBody>,

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

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

+ &Locals { ptr: ArenaMap::new(), body, drop_flags: DropFlags::default() },

+ code_stack: vec![],

+ layout_cache: RefCell::new(HashMap::default()),

+ fn place_addr(&self, p: &Place, locals: &Locals) -> Result<Address> {

+ fn place_interval(&self, p: &Place, locals: &Locals) -> Result<Interval> {

+ locals: &'a Locals,

+ if let Some(x) = self.layout_cache.borrow().get(ty) {

+ return Ok(x.clone());

+ }

+ let r = self

+ .db

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

+ self.layout_cache.borrow_mut().insert(ty.clone(), r.clone());

+ Ok(r)

+ fn place_ty<'a>(&'a self, p: &Place, locals: &'a Locals) -> Result<Ty> {

+ fn operand_ty(&self, o: &Operand, locals: &Locals) -> Result<Ty> {

+ fn operand_ty_and_eval(&mut self, o: &Operand, locals: &mut Locals) -> Result<IntervalAndTy> {

+ body: Arc<MirBody>,

+ args: impl Iterator<Item = IntervalOrOwned>,

+ let (mut locals, prev_stack_ptr) = self.create_locals_for_body(body.clone(), None)?;

+ self.fill_locals_for_body(&body, &mut locals, args)?;

+ let prev_code_stack = mem::take(&mut self.code_stack);

+ let span = (MirSpan::Unknown, body.owner);

+ self.code_stack.push(StackFrame { body, locals, destination: None, prev_stack_ptr, span });

+ 'stack: loop {

+ let Some(mut my_stack_frame) = self.code_stack.pop() else {

+ not_supported!("missing stack frame");

+ };

+ let e = (|| {

+ let mut locals = &mut my_stack_frame.locals;

+ let body = &*my_stack_frame.body;

+ loop {

+ let current_block = &body.basic_blocks[current_block_idx];

+ if let Some(it) = self.execution_limit.checked_sub(1) {

+ self.execution_limit = it;

+ } else {

+ return Err(MirEvalError::ExecutionLimitExceeded);

+ }

+ for statement in &current_block.statements {

+ match &statement.kind {

+ StatementKind::Assign(l, r) => {

+ let addr = self.place_addr(l, &locals)?;

+ let result = self.eval_rvalue(r, &mut locals)?.to_vec(&self)?;

+ self.write_memory(addr, &result)?;

+ locals.drop_flags.add_place(l.clone());

+ }

+ StatementKind::Deinit(_) => not_supported!("de-init statement"),

+ StatementKind::StorageLive(_)

+ | StatementKind::StorageDead(_)

+ | StatementKind::Nop => (),

+ }

+ }

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

+ not_supported!("block without terminator");

+ };

+ match &terminator.kind {

+ TerminatorKind::Goto { target } => {

+ current_block_idx = *target;

+ }

+ TerminatorKind::Call {

+ func,

+ args,

+ destination,

+ target,

+ cleanup: _,

+ from_hir_call: _,

+ } => {

+ let destination_interval = self.place_interval(destination, &locals)?;

+ let fn_ty = self.operand_ty(func, &locals)?;

+ let args = args

+ .iter()

+ .map(|it| self.operand_ty_and_eval(it, &mut locals))

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

+ let stack_frame = match &fn_ty.data(Interner).kind {

+ TyKind::Function(_) => {

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

+ self.exec_fn_pointer(

+ bytes,

+ destination_interval,

+ &args,

+ &locals,

+ *target,

+ terminator.span,

+ )?

+ }

+ TyKind::FnDef(def, generic_args) => self.exec_fn_def(

+ *def,

+ generic_args,

+ destination_interval,

+ &args,

+ &locals,

+ *target,

+ terminator.span,

+ )?,

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

+ };

+ locals.drop_flags.add_place(destination.clone());

+ if let Some(stack_frame) = stack_frame {

+ self.code_stack.push(my_stack_frame);

+ current_block_idx = stack_frame.body.start_block;

+ self.code_stack.push(stack_frame);

+ return Ok(None);

+ } else {

+ current_block_idx =

+ target.ok_or(MirEvalError::UndefinedBehavior(

+ "Diverging function returned".to_owned(),

+ ))?;

+ }

+ }

+ TerminatorKind::SwitchInt { discr, targets } => {

+ let val = u128::from_le_bytes(pad16(

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

+ false,

+ ));

+ current_block_idx = targets.target_for_value(val);

+ }

+ TerminatorKind::Return => {

+ break;

+ }

+ TerminatorKind::Unreachable => {

+ return Err(MirEvalError::UndefinedBehavior(

+ "unreachable executed".to_owned(),

+ ));

+ }

+ TerminatorKind::Drop { place, target, unwind: _ } => {

+ self.drop_place(place, &mut locals, terminator.span)?;

+ current_block_idx = *target;

+ }

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

+ }

+ }

+ Ok(Some(my_stack_frame))

+ })();

+ let my_stack_frame = match e {

+ Ok(None) => continue 'stack,

+ Ok(Some(x)) => x,

+ Err(e) => {

+ let my_code_stack = mem::replace(&mut self.code_stack, prev_code_stack);

+ let mut error_stack = vec![];

+ for frame in my_code_stack.into_iter().rev() {

+ if let DefWithBodyId::FunctionId(f) = frame.body.owner {

+ error_stack.push((Either::Left(f), frame.span.0, frame.span.1));

+ }

+ }

+ return Err(MirEvalError::InFunction(Box::new(e), error_stack));

+ }

+ };

+ match my_stack_frame.destination {

+ None => {

+ self.code_stack = prev_code_stack;

+ self.stack_depth_limit += 1;

+ return Ok(my_stack_frame.locals.ptr[return_slot()].get(self)?.to_vec());

+ }

+ Some(bb) => {

+ // We don't support const promotion, so we can't truncate the stack yet.

+ let _ = my_stack_frame.prev_stack_ptr;

+ // self.stack.truncate(my_stack_frame.prev_stack_ptr);

+ current_block_idx = bb;

+ }

+ }

+ }

+ }

+

+ fn fill_locals_for_body(

+ &mut self,

+ body: &MirBody,

+ locals: &mut Locals,

+ args: impl Iterator<Item = IntervalOrOwned>,

+ ) -> Result<()> {

+ let mut remain_args = body.param_locals.len();

+ for ((l, interval), value) in locals.ptr.iter().skip(1).zip(args) {

+ locals.drop_flags.add_place(l.into());

+ match value {

+ IntervalOrOwned::Owned(value) => interval.write_from_bytes(self, &value)?,

+ IntervalOrOwned::Borrowed(value) => interval.write_from_interval(self, value)?,

+ }

+ if remain_args == 0 {

+ return Err(MirEvalError::TypeError("more arguments provided"));

+ }

+ remain_args -= 1;

+ }

+ if remain_args > 0 {

+ return Err(MirEvalError::TypeError("not enough arguments provided"));

+ }

+ Ok(())

+ }

+

+ fn create_locals_for_body(

+ &mut self,

+ body: Arc<MirBody>,

+ destination: Option<Interval>,

+ ) -> Result<(Locals, usize)> {

+ Locals { ptr: ArenaMap::new(), body: body.clone(), drop_flags: DropFlags::default() };

+ if id == return_slot() {

+ if let Some(destination) = destination {

+ return Ok((id, destination));

+ }

+ }

+ locals.ptr = locals_ptr;

+ let prev_stack_pointer = self.stack.len();

+ Ok((locals, prev_stack_pointer))

+ fn eval_rvalue(&mut self, r: &Rvalue, locals: &mut Locals) -> Result<IntervalOrOwned> {

+ locals: &Locals,

+ fn eval_operand(&mut self, it: &Operand, locals: &mut Locals) -> Result<Interval> {

+ locals: &Locals,

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

+ fn size_align_of(&self, ty: &Ty, locals: &Locals) -> Result<Option<(usize, usize)>> {

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

+ locals: &Locals,

+ let l = self.db.lang_attr(parent.into())?;

+ fn create_memory_map(&self, bytes: &[u8], ty: &Ty, locals: &Locals) -> Result<MemoryMap> {

+ locals: &Locals,

+ locals: &Locals,

+ locals: &Locals,

+ target_bb: Option<BasicBlockId>,

+ ) -> Result<Option<StackFrame>> {

+ self.exec_fn_def(*def, generic_args, destination, args, &locals, target_bb, span)

+ self.exec_closure(*id, bytes.slice(0..0), subst, destination, args, locals, span)

+ _ => Err(MirEvalError::TypeError("function pointer to non function")),

+ locals: &Locals,

+ ) -> Result<Option<StackFrame>> {

+ let bytes = self

+ .interpret_mir(mir_body, arg_bytes.into_iter().map(IntervalOrOwned::Owned))

+ .map_err(|e| {

+ MirEvalError::InFunction(

+ Box::new(e),

+ vec![(Either::Right(closure), span, locals.body.owner)],

+ )

+ })?;

+ destination.write_from_bytes(self, &bytes)?;

+ Ok(None)

+ locals: &Locals,

+ target_bb: Option<BasicBlockId>,

+ ) -> Result<Option<StackFrame>> {

+ return self.exec_fn_trait(

+ def,

+ args,

+ generic_args,

+ locals,

+ destination,

+ target_bb,

+ span,

+ );

+ self.exec_fn_with_args(

+ def,

+ args,

+ generic_args,

+ locals,

+ destination,

+ target_bb,

+ span,

+ )

+ Ok(None)

+ Ok(None)

+ locals: &Locals,

+ target_bb: Option<BasicBlockId>,

+ ) -> Result<Option<StackFrame>> {

+ return Ok(None);

+ let arg_bytes = args.iter().map(|it| IntervalOrOwned::Borrowed(it.interval));

+ let first_arg = arg_bytes.clone().next().unwrap();

+ let first_arg = first_arg.get(self)?;

+ self.vtable_map.ty_of_bytes(&first_arg[self.ptr_size()..self.ptr_size() * 2])?;

+ target_bb,

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

+ self.exec_looked_up_function(

+ generic_args,

+ locals,

+ imp,

+ arg_bytes,

+ span,

+ destination,

+ target_bb,

+ )

+ locals: &Locals,

+ arg_bytes: impl Iterator<Item = IntervalOrOwned>,

+ target_bb: Option<BasicBlockId>,

+ ) -> Result<Option<StackFrame>> {

+ vec![(Either::Left(imp), span, locals.body.owner)],

+ Ok(if let Some(target_bb) = target_bb {

+ let (mut locals, prev_stack_ptr) =

+ self.create_locals_for_body(mir_body.clone(), Some(destination))?;

+ self.fill_locals_for_body(&mir_body, &mut locals, arg_bytes.into_iter())?;

+ let span = (span, locals.body.owner);

+ Some(StackFrame {

+ body: mir_body,

+ locals,

+ destination: Some(target_bb),

+ prev_stack_ptr,

+ span,

+ })

+ } else {

+ let result = self.interpret_mir(mir_body, arg_bytes).map_err(|e| {

+ MirEvalError::InFunction(

+ Box::new(e),

+ vec![(Either::Left(imp), span, locals.body.owner)],

+ )

+ })?;

+ destination.write_from_bytes(self, &result)?;

+ None

+ })

+ locals: &Locals,

+ target_bb: Option<BasicBlockId>,

+ ) -> Result<Option<StackFrame>> {

+ return self.exec_fn_def(

+ *def,

+ subst,

+ destination,

+ &args[1..],

+ locals,

+ target_bb,

+ span,

+ );

+ return self.exec_fn_pointer(

+ func_data,

+ destination,

+ &args[1..],

+ locals,

+ target_bb,

+ span,

+ );

+ return self.exec_closure(

+ );

+ target_bb,

+ fn eval_static(&mut self, st: StaticId, locals: &Locals) -> Result<Address> {

+ fn drop_place(&mut self, place: &Place, locals: &mut Locals, span: MirSpan) -> Result<()> {

+ locals: &Locals,

+ let (impl_drop_candidate, subst) = self.db.lookup_impl_method(

+ [IntervalOrOwned::Owned(addr.to_bytes())].into_iter(),

+ None,

+ locals: &Locals,

+ let candidate = self.db.lang_attr(def.into())?;

+ locals: &Locals,

+ let message_string = self.interpret_mir(self.db.mir_body(format_fn.into()).map_err(|e| MirEvalError::MirLowerError(format_fn, e))?, args.map(|x| IntervalOrOwned::Owned(x.clone())))?;

+ locals: &Locals,

+ locals: &Locals,

+ locals: &Locals,

+ self.exec_fn_trait(

+ None,

+ )?;

+ return Ok(());

+ locals: &Locals,

+ locals: &Locals,

+ _locals: &Locals,

+ let (result, stdout, stderr) = interpret_mir(db, body, false);

+use hir_def::FunctionId;

+ if let Some(lang_item) = self.db.lang_attr(id.0.into()) {

+ let (result, stdout, stderr) = interpret_mir(db, body, false);

+ db.lookup_impl_method(env, func, substs).0