+ fmt,

+ string,

+ String,

+ as_str,

+ format,

+ //- minicore: coerce_unsized, transmute

+ use core::mem::transmute;

+

+ extern "rust-intrinsic" {

+ pub fn size_of_val<T: ?Sized>(_: *const T) -> usize;

+ }

+

+ struct X {

+ x: i64,

+ y: u8,

+ t: [i32],

+ }

+

+ const GOAL: usize = unsafe {

+ let y: &X = transmute([0usize, 3]);

+ size_of_val(y)

+ };

+ "#,

+ 24,

+ );

+ check_number(

+ r#"

+ //- minicore: coerce_unsized, transmute

+ use core::mem::transmute;

+

+ extern "rust-intrinsic" {

+ pub fn size_of_val<T: ?Sized>(_: *const T) -> usize;

+ }

+

+ struct X {

+ x: i32,

+ y: i64,

+ t: [u8],

+ }

+

+ const GOAL: usize = unsafe {

+ let y: &X = transmute([0usize, 15]);

+ size_of_val(y)

+ };

+ "#,

+ 32,

+ );

+ check_number(

+ r#"

+fn min_align_of_val() {

+ check_number(

+ r#"

+ //- minicore: coerce_unsized

+ extern "rust-intrinsic" {

+ pub fn min_align_of_val<T: ?Sized>(_: *const T) -> usize;

+ }

+

+ struct X(i32, u8);

+

+ const GOAL: usize = min_align_of_val(&X(1, 2));

+ "#,

+ 4,

+ );

+ check_number(

+ r#"

+ //- minicore: coerce_unsized

+ extern "rust-intrinsic" {

+ pub fn min_align_of_val<T: ?Sized>(_: *const T) -> usize;

+ }

+

+ const GOAL: usize = {

+ let x: &[i32] = &[1, 2, 3];

+ min_align_of_val(x)

+ };

+ "#,

+ 4,

+ );

+}

+

+#[test]

+ .and_then(|x| x.last().map(|x| !x.is_unsized()))

+use chalk_ir::TyKind;

+use hir_def::resolver::HasResolver;

+use hir_expand::mod_path::ModPath;

+

+ let x = self.db.crate_def_map(self.crate_id).crate_root();

+ let resolver = x.resolver(self.db.upcast());

+ let Some(format_fn) = resolver.resolve_path_in_value_ns_fully(

+ self.db.upcast(),

+ &hir_def::path::Path::from_known_path_with_no_generic(ModPath::from_segments(

+ hir_expand::mod_path::PathKind::Abs,

+ [name![std], name![fmt], name![format]].into_iter(),

+ )),

+ ) else {

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

+ };

+ let hir_def::resolver::ValueNs::FunctionId(format_fn) = format_fn else { not_supported!("std::fmt::format is not a function") };

+ let message_string = self.interpret_mir(&*self.db.mir_body(format_fn.into()).map_err(|e| MirEvalError::MirLowerError(format_fn, e))?, args.cloned())?;

+ let addr = Address::from_bytes(&message_string[self.ptr_size()..2 * self.ptr_size()])?;

+ let size = from_bytes!(usize, message_string[2 * self.ptr_size()..]);

+ Ok(std::string::String::from_utf8_lossy(self.read_memory(addr, size)?).into_owned())

+ .unwrap_or_else(|e| format!("Failed to render panic format args: {e:?}"));

+ "min_align_of" | "pref_align_of" => {

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {

+ return Err(MirEvalError::TypeError("align_of generic arg is not provided"));

+ };

+ let align = self.layout(ty)?.align.abi.bytes();

+ destination.write_from_bytes(self, &align.to_le_bytes()[0..destination.size])

+ }

+ if let Some((size, _)) = self.size_align_of(ty, locals)? {

+ destination.write_from_bytes(self, &size.to_le_bytes())

+ } else {

+ let metadata = arg.interval.slice(self.ptr_size()..self.ptr_size() * 2);

+ let (size, _) = self.size_align_of_unsized(ty, metadata, locals)?;

+ destination.write_from_bytes(self, &size.to_le_bytes())

+ }

+ "min_align_of_val" => {

+ let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|x| x.ty(Interner)) else {

+ return Err(MirEvalError::TypeError("min_align_of_val generic arg is not provided"));

+ let [arg] = args else {

+ return Err(MirEvalError::TypeError("min_align_of_val args are not provided"));

+ };

+ if let Some((_, align)) = self.size_align_of(ty, locals)? {

+ destination.write_from_bytes(self, &align.to_le_bytes())

+ } else {

+ let metadata = arg.interval.slice(self.ptr_size()..self.ptr_size() * 2);

+ let (_, align) = self.size_align_of_unsized(ty, metadata, locals)?;

+ destination.write_from_bytes(self, &align.to_le_bytes())

+ }

+ fn size_align_of_unsized(

+ &mut self,

+ ty: &Ty,

+ metadata: Interval,

+ locals: &Locals<'_>,

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

+ Ok(match ty.kind(Interner) {

+ TyKind::Str => (from_bytes!(usize, metadata.get(self)?), 1),

+ TyKind::Slice(inner) => {

+ let len = from_bytes!(usize, metadata.get(self)?);

+ let (size, align) = self.size_align_of_sized(inner, locals, "slice inner type")?;

+ (size * len, align)

+ }

+ TyKind::Dyn(_) => self.size_align_of_sized(

+ self.vtable_map.ty_of_bytes(metadata.get(self)?)?,

+ locals,

+ "dyn concrete type",

+ )?,

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

+ let id = id.0;

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

+ let id = match id {

+ AdtId::StructId(s) => s,

+ _ => not_supported!("unsized enum or union"),

+ };

+ let field_types = &self.db.field_types(id.into());

+ let last_field_ty =

+ field_types.iter().rev().next().unwrap().1.clone().substitute(Interner, subst);

+ let sized_part_size =

+ layout.fields.offset(field_types.iter().count() - 1).bytes_usize();

+ let sized_part_align = layout.align.abi.bytes() as usize;

+ let (unsized_part_size, unsized_part_align) =

+ self.size_align_of_unsized(&last_field_ty, metadata, locals)?;

+ let align = sized_part_align.max(unsized_part_align) as isize;

+ let size = (sized_part_size + unsized_part_size) as isize;

+ // Must add any necessary padding to `size`

+ // (to make it a multiple of `align`) before returning it.

+ //

+ // Namely, the returned size should be, in C notation:

+ //

+ // `size + ((size & (align-1)) ? align : 0)`

+ //

+ // emulated via the semi-standard fast bit trick:

+ //

+ // `(size + (align-1)) & -align`

+ let size = (size + (align - 1)) & (-align);

+ (size as usize, align as usize)

+ }

+ _ => not_supported!("unsized type other than str, slice, struct and dyn"),

+ })

+ }

+

+use std::cmp::Ordering;

+

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

+ let len = match subst.as_slice(Interner).get(1).and_then(|x| x.constant(Interner)) {

+ Some(len) => len,

+ _ => {

+ if let AdtId::StructId(id) = id.0 {

+ return Ok(self.db.struct_data(id).variant_data.fields().len());

+ }

+ return Err(MirEvalError::TypeError("simd type with no len param"));

+ }

+ "eq" | "ne" | "lt" | "le" | "gt" | "ge" => {

+ return Err(MirEvalError::TypeError("simd args are not provided"));

+ let len = self.detect_simd_ty(&left.ty)?;

+ let size = left.interval.size / len;

+ let dest_size = destination.size / len;

+ let mut destination_bytes = vec![];

+ let vector = left.get(self)?.chunks(size).zip(right.get(self)?.chunks(size));

+ for (l, r) in vector {

+ let mut result = Ordering::Equal;

+ for (l, r) in l.iter().zip(r).rev() {

+ let x = l.cmp(r);

+ if x != Ordering::Equal {

+ result = x;

+ break;

+ }

+ }

+ let result = match result {

+ Ordering::Less => ["lt", "le", "ne"].contains(&name),

+ Ordering::Equal => ["ge", "le", "eq"].contains(&name),

+ Ordering::Greater => ["ge", "gt", "ne"].contains(&name),

+ };

+ let result = if result { 255 } else { 0 };

+ destination_bytes.extend(std::iter::repeat(result).take(dest_size));

+ }

+

+ destination.write_from_bytes(self, &destination_bytes)

+ let left_size = left.interval.size / left_len;

+ left.get(self)?.chunks(left_size).chain(right.get(self)?.chunks(left_size));

+ field_a: u8 // size = 1, align = 1, offset = 6