rust-analyzer

diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index d81926f7c9..4468b96b77 100644
--- a/crates/hir-ty/src/display.rs
+++ b/crates/hir-ty/src/display.rs

@@ -515,7 +515,7 @@ fn render_const_scalar(

TyKind::Dyn(_) => {

let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());

let ty_id = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());

- let Ok(t) = memory_map.vtable.ty(ty_id) else {

+ let Ok(t) = memory_map.vtable_ty(ty_id) else {

return f.write_str("<ty-missing-in-vtable-map>");

};

let Ok(layout) = f.db.layout_of_ty(t.clone(), trait_env) else {

diff --git a/crates/hir-ty/src/infer/closure.rs b/crates/hir-ty/src/infer/closure.rs
index ac00b00fcd..8a832b6b90 100644
--- a/crates/hir-ty/src/infer/closure.rs
+++ b/crates/hir-ty/src/infer/closure.rs

@@ -1,6 +1,6 @@

//! Inference of closure parameter types based on the closure's expected type.

-use std::{cmp, collections::HashMap, convert::Infallible, mem};

+use std::{cmp, convert::Infallible, mem};

use chalk_ir::{

cast::Cast,

@@ -778,7 +778,7 @@ impl InferenceContext<'_> {

fn minimize_captures(&mut self) {

self.current_captures.sort_by_key(|it| it.place.projections.len());

- let mut hash_map = HashMap::<HirPlace, usize>::new();

+ let mut hash_map = FxHashMap::<HirPlace, usize>::default();

let result = mem::take(&mut self.current_captures);

for item in result {

let mut lookup_place = HirPlace { local: item.place.local, projections: vec![] };

diff --git a/crates/hir-ty/src/interner.rs b/crates/hir-ty/src/interner.rs
index 7d3539edad..eb6296f7a0 100644
--- a/crates/hir-ty/src/interner.rs
+++ b/crates/hir-ty/src/interner.rs

@@ -36,35 +36,6 @@ impl<T> std::ops::Deref for InternedWrapper<T> {

}

-#[derive(Eq)]

-pub struct PreHashedWrapper<T>(T, u64);

-impl<T: fmt::Debug> fmt::Debug for PreHashedWrapper<T> {

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

- fmt::Debug::fmt(&self.0, f)

- }

-impl<T: PartialEq> PartialEq for PreHashedWrapper<T> {

- fn eq(&self, other: &Self) -> bool {

- self.1 == other.1 && self.0 == other.0

- }

-impl<T> std::ops::Deref for PreHashedWrapper<T> {

- type Target = T;

- fn deref(&self) -> &Self::Target {

- &self.0

- }

-impl<T: std::hash::Hash> std::hash::Hash for PreHashedWrapper<T> {

- fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

- state.write_u64(self.1);

- }

impl_internable!(

InternedWrapper<Vec<VariableKind>>,

InternedWrapper<SmallVec<[GenericArg; 2]>>,

@@ -76,7 +47,6 @@ impl_internable!(

InternedWrapper<Vec<ProgramClause>>,

InternedWrapper<Vec<QuantifiedWhereClause>>,

InternedWrapper<SmallVec<[Variance; 16]>>,

- // InternedWrapper<PreHashedWrapper<Goals>>,

);

impl chalk_ir::interner::Interner for Interner {

@@ -88,7 +58,6 @@ impl chalk_ir::interner::Interner for Interner {

// We could do the following, but that saves "only" 20mb on self while increasing inferecene

// time by ~2.5%

// type InternedGoal = Interned<InternedWrapper<GoalData>>;

- // type InternedGoal = Interned<InternedWrapper<PreHashedWrapper<GoalData>>>;

type InternedGoal = Arc<GoalData>;

type InternedGoals = Vec<Goal>;

type InternedSubstitution = Interned<InternedWrapper<SmallVec<[GenericArg; 2]>>>;

@@ -97,7 +66,6 @@ impl chalk_ir::interner::Interner for Interner {

type InternedQuantifiedWhereClauses = Interned<InternedWrapper<Vec<QuantifiedWhereClause>>>;

type InternedVariableKinds = Interned<InternedWrapper<Vec<VariableKind>>>;

type InternedCanonicalVarKinds = Interned<InternedWrapper<Vec<CanonicalVarKind>>>;

- // type InternedConstraints = SmallVec<[InEnvironment<Constraint>; 1]>;

type InternedConstraints = Vec<InEnvironment<Constraint>>;

type InternedVariances = SmallVec<[Variance; 16]>;

type DefId = InternId;

diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs
index 964ca7ce94..793b52b49f 100644
--- a/crates/hir-ty/src/lib.rs
+++ b/crates/hir-ty/src/lib.rs

@@ -37,8 +37,8 @@ mod tests;

mod test_db;

use std::{

- collections::{hash_map::Entry, HashMap},

- hash::Hash,

+ collections::hash_map::Entry,

+ hash::{BuildHasherDefault, Hash},

};

use chalk_ir::{

@@ -52,7 +52,7 @@ use hir_def::{hir::ExprId, type_ref::Rawness, GeneralConstId, TypeOrConstParamId

use hir_expand::name;

use la_arena::{Arena, Idx};

use mir::{MirEvalError, VTableMap};

-use rustc_hash::FxHashSet;

+use rustc_hash::{FxHashMap, FxHashSet};

use syntax::ast::{make, ConstArg};

use traits::FnTrait;

use triomphe::Arc;

@@ -171,24 +171,45 @@ pub type Variances = chalk_ir::Variances<Interner>;

/// the necessary bits of memory of the const eval session to keep the constant

/// meaningful.

#[derive(Debug, Default, Clone, PartialEq, Eq)]

-pub struct MemoryMap {

- pub memory: HashMap<usize, Vec<u8>>,

- pub vtable: VTableMap,

+pub enum MemoryMap {

+ #[default]

+ Empty,

+ Simple(Box<[u8]>),

+ Complex(Box<ComplexMemoryMap>),

}

-impl MemoryMap {

- fn insert(&mut self, addr: usize, x: Vec<u8>) {

+#[derive(Debug, Default, Clone, PartialEq, Eq)]

+pub struct ComplexMemoryMap {

+ memory: FxHashMap<usize, Box<[u8]>>,

+ vtable: VTableMap,

+impl ComplexMemoryMap {

+ fn insert(&mut self, addr: usize, val: Box<[u8]>) {

match self.memory.entry(addr) {

Entry::Occupied(mut e) => {

- if e.get().len() < x.len() {

- e.insert(x);

+ if e.get().len() < val.len() {

+ e.insert(val);

}

Entry::Vacant(e) => {

- e.insert(x);

+ e.insert(val);

}

+impl MemoryMap {

+ pub fn vtable_ty(&self, id: usize) -> Result<&Ty, MirEvalError> {

+ match self {

+ MemoryMap::Empty | MemoryMap::Simple(_) => Err(MirEvalError::InvalidVTableId(id)),

+ MemoryMap::Complex(cm) => cm.vtable.ty(id),

+ }

+ fn simple(v: Box<[u8]>) -> Self {

+ MemoryMap::Simple(v)

+ }

/// This functions convert each address by a function `f` which gets the byte intervals and assign an address

/// to them. It is useful when you want to load a constant with a memory map in a new memory. You can pass an

@@ -196,22 +217,33 @@ impl MemoryMap {

fn transform_addresses(

&self,

mut f: impl FnMut(&[u8], usize) -> Result<usize, MirEvalError>,

- ) -> Result<HashMap<usize, usize>, MirEvalError> {

- self.memory

- .iter()

- .map(|x| {

- let addr = *x.0;

- let align = if addr == 0 { 64 } else { (addr - (addr & (addr - 1))).min(64) };

- Ok((addr, f(x.1, align)?))

- })

- .collect()

+ ) -> Result<FxHashMap<usize, usize>, MirEvalError> {

+ let mut transform = |(addr, val): (&usize, &Box<[u8]>)| {

+ let addr = *addr;

+ let align = if addr == 0 { 64 } else { (addr - (addr & (addr - 1))).min(64) };

+ f(val, align).and_then(|it| Ok((addr, it)))

+ };

+ match self {

+ MemoryMap::Empty => Ok(Default::default()),

+ MemoryMap::Simple(m) => transform((&0, m)).map(|(addr, val)| {

+ let mut map = FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());

+ map.insert(addr, val);

+ map

+ }),

+ MemoryMap::Complex(cm) => cm.memory.iter().map(transform).collect(),

+ }

}

- fn get<'a>(&'a self, addr: usize, size: usize) -> Option<&'a [u8]> {

+ fn get(&self, addr: usize, size: usize) -> Option<&[u8]> {

if size == 0 {

Some(&[])

} else {

- self.memory.get(&addr)?.get(0..size)

+ match self {

+ MemoryMap::Empty => Some(&[]),

+ MemoryMap::Simple(m) if addr == 0 => m.get(0..size),

+ MemoryMap::Simple(_) => None,

+ MemoryMap::Complex(cm) => cm.memory.get(&addr)?.get(0..size),

+ }

}

diff --git a/crates/hir-ty/src/mir/eval.rs b/crates/hir-ty/src/mir/eval.rs
index 4c06566e7c..5650956d2f 100644
--- a/crates/hir-ty/src/mir/eval.rs
+++ b/crates/hir-ty/src/mir/eval.rs

@@ -1,13 +1,6 @@

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

-use std::{

- borrow::Cow,

- cell::RefCell,

- collections::{HashMap, HashSet},

- fmt::Write,

- iter, mem,

- ops::Range,

-};

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

use base_db::{CrateId, FileId};

use chalk_ir::{cast::Cast, Mutability};

@@ -40,8 +33,8 @@ use crate::{

name, static_lifetime,

traits::FnTrait,

utils::{detect_variant_from_bytes, ClosureSubst},

- CallableDefId, ClosureId, Const, ConstScalar, FnDefId, Interner, MemoryMap, Substitution,

- TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,

+ CallableDefId, ClosureId, ComplexMemoryMap, Const, ConstScalar, FnDefId, Interner, MemoryMap,

+ Substitution, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,

};

use super::{

@@ -98,6 +91,15 @@ impl VTableMap {

let id = from_bytes!(usize, bytes);

self.ty(id)

}

+ pub fn shrink_to_fit(&mut self) {

+ self.id_to_ty.shrink_to_fit();

+ self.ty_to_id.shrink_to_fit();

+ }

+ fn is_empty(&self) -> bool {

+ self.id_to_ty.is_empty() && self.ty_to_id.is_empty()

+ }

}

#[derive(Debug, Default, Clone, PartialEq, Eq)]

@@ -251,13 +253,6 @@ impl From<Interval> for IntervalOrOwned {

}

impl IntervalOrOwned {

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

- Ok(match self {

- IntervalOrOwned::Owned(o) => o,

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

- })

- }

fn get<'a>(&'a self, memory: &'a Evaluator<'a>) -> Result<&'a [u8]> {

Ok(match self {

IntervalOrOwned::Owned(o) => o,

@@ -291,8 +286,8 @@ impl Address {

}

- fn to_bytes(&self) -> Vec<u8> {

- usize::to_le_bytes(self.to_usize()).to_vec()

+ fn to_bytes(&self) -> [u8; mem::size_of::<usize>()] {

+ usize::to_le_bytes(self.to_usize())

}

fn to_usize(&self) -> usize {

@@ -510,6 +505,20 @@ struct Locals {

drop_flags: DropFlags,

}

+pub struct MirOutput {

+ stdout: Vec<u8>,

+ stderr: Vec<u8>,

+impl MirOutput {

+ pub fn stdout(&self) -> Cow<'_, str> {

+ String::from_utf8_lossy(&self.stdout)

+ }

+ pub fn stderr(&self) -> Cow<'_, str> {

+ String::from_utf8_lossy(&self.stderr)

+ }

pub fn interpret_mir(

db: &dyn HirDatabase,

body: Arc<MirBody>,

@@ -520,7 +529,7 @@ pub fn interpret_mir(

// (and probably should) do better here, for example by excluding bindings outside of the target expression.

assert_placeholder_ty_is_unused: bool,

trait_env: Option<Arc<TraitEnvironment>>,

-) -> (Result<Const>, String, String) {

+) -> (Result<Const>, MirOutput) {

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

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

let it: Result<Const> = (|| {

@@ -534,14 +543,17 @@ pub fn interpret_mir(

&ty,

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

)?;

- memory_map.vtable = evaluator.vtable_map.clone();

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

+ let bytes = bytes.into();

+ let memory_map = if memory_map.memory.is_empty() && evaluator.vtable_map.is_empty() {

+ MemoryMap::Empty

+ } else {

+ memory_map.vtable = mem::take(&mut evaluator.vtable_map);

+ memory_map.vtable.shrink_to_fit();

+ MemoryMap::Complex(Box::new(memory_map))

+ };

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

})();

- (

- it,

- String::from_utf8_lossy(&evaluator.stdout).into_owned(),

- String::from_utf8_lossy(&evaluator.stderr).into_owned(),

- )

+ (it, MirOutput { stdout: evaluator.stdout, stderr: evaluator.stderr })

}

#[cfg(test)]

@@ -563,7 +575,7 @@ impl Evaluator<'_> {

code_stack: vec![],

vtable_map: VTableMap::default(),

thread_local_storage: TlsData::default(),

- static_locations: HashMap::default(),

+ static_locations: Default::default(),

db,

random_state: oorandom::Rand64::new(0),

trait_env: trait_env.unwrap_or_else(|| db.trait_environment_for_body(owner)),

@@ -574,11 +586,11 @@ impl Evaluator<'_> {

stack_depth_limit: 100,

execution_limit: EXECUTION_LIMIT,

memory_limit: 1000_000_000, // 2GB, 1GB for stack and 1GB for heap

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

- projected_ty_cache: RefCell::new(HashMap::default()),

- not_special_fn_cache: RefCell::new(HashSet::default()),

- mir_or_dyn_index_cache: RefCell::new(HashMap::default()),

- unused_locals_store: RefCell::new(HashMap::default()),

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

+ projected_ty_cache: RefCell::new(Default::default()),

+ not_special_fn_cache: RefCell::new(Default::default()),

+ mir_or_dyn_index_cache: RefCell::new(Default::default()),

+ unused_locals_store: RefCell::new(Default::default()),

cached_ptr_size: match db.target_data_layout(crate_id) {

Some(it) => it.pointer_size.bytes_usize(),

None => 8,

@@ -838,8 +850,8 @@ impl Evaluator<'_> {

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)?;

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

+ self.copy_from_interval_or_owned(addr, result)?;

locals

.drop_flags

.add_place(l.clone(), &locals.body.projection_store);

@@ -1051,7 +1063,7 @@ impl Evaluator<'_> {

Rvalue::Use(it) => Borrowed(self.eval_operand(it, locals)?),

Rvalue::Ref(_, p) => {

let (addr, _, metadata) = self.place_addr_and_ty_and_metadata(p, locals)?;

- let mut r = addr.to_bytes();

+ let mut r = addr.to_bytes().to_vec();

if let Some(metadata) = metadata {

r.extend(metadata.get(self)?);

}

@@ -1284,7 +1296,7 @@ impl Evaluator<'_> {

not_supported!("unsized box initialization");

};

let addr = self.heap_allocate(size, align)?;

- Owned(addr.to_bytes())

+ Owned(addr.to_bytes().to_vec())

}

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

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

@@ -1716,7 +1728,18 @@ impl Evaluator<'_> {

}

let addr = self.heap_allocate(size, align)?;

self.write_memory(addr, &v)?;

- self.patch_addresses(&patch_map, &memory_map.vtable, addr, ty, locals)?;

+ self.patch_addresses(

+ &patch_map,

+ |bytes| match &memory_map {

+ MemoryMap::Empty | MemoryMap::Simple(_) => {

+ Err(MirEvalError::InvalidVTableId(from_bytes!(usize, bytes)))

+ }

+ MemoryMap::Complex(cm) => cm.vtable.ty_of_bytes(bytes),

+ },

+ addr,

+ ty,

+ locals,

+ )?;

Ok(Interval::new(addr, size))

}

@@ -1768,6 +1791,13 @@ impl Evaluator<'_> {

Ok(())

}

+ fn copy_from_interval_or_owned(&mut self, addr: Address, r: IntervalOrOwned) -> Result<()> {

+ match r {

+ IntervalOrOwned::Borrowed(r) => self.copy_from_interval(addr, r),

+ IntervalOrOwned::Owned(r) => self.write_memory(addr, &r),

+ }

fn copy_from_interval(&mut self, addr: Address, r: Interval) -> Result<()> {

if r.size == 0 {

return Ok(());

@@ -1888,13 +1918,18 @@ impl Evaluator<'_> {

}

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

+ fn create_memory_map(

+ &self,

+ bytes: &[u8],

+ ty: &Ty,

+ locals: &Locals,

+ ) -> Result<ComplexMemoryMap> {

fn rec(

this: &Evaluator<'_>,

bytes: &[u8],

ty: &Ty,

locals: &Locals,

- mm: &mut MemoryMap,

+ mm: &mut ComplexMemoryMap,

) -> Result<()> {

match ty.kind(Interner) {

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

@@ -1904,7 +1939,7 @@ impl Evaluator<'_> {

let addr_usize = from_bytes!(usize, bytes);

mm.insert(

addr_usize,

- this.read_memory(Address::from_usize(addr_usize), size)?.to_vec(),

+ this.read_memory(Address::from_usize(addr_usize), size)?.into(),

)

}

None => {

@@ -1930,7 +1965,7 @@ impl Evaluator<'_> {

let size = element_size * count;

let addr = Address::from_bytes(addr)?;

let b = this.read_memory(addr, size)?;

- mm.insert(addr.to_usize(), b.to_vec());

+ mm.insert(addr.to_usize(), b.into());

if let Some(ty) = check_inner {

for i in 0..count {

let offset = element_size * i;

@@ -2003,15 +2038,15 @@ impl Evaluator<'_> {

}

Ok(())

}

- let mut mm = MemoryMap::default();

- rec(self, bytes, ty, locals, &mut mm)?;

+ let mut mm = ComplexMemoryMap::default();

+ rec(&self, bytes, ty, locals, &mut mm)?;

Ok(mm)

}

- fn patch_addresses(

+ fn patch_addresses<'vtable>(

&mut self,

- patch_map: &HashMap<usize, usize>,

- old_vtable: &VTableMap,

+ patch_map: &FxHashMap<usize, usize>,

+ ty_of_bytes: impl Fn(&[u8]) -> Result<&'vtable Ty> + Copy,

addr: Address,

ty: &Ty,

locals: &Locals,

@@ -2038,7 +2073,7 @@ impl Evaluator<'_> {

}

TyKind::Function(_) => {

- let ty = old_vtable.ty_of_bytes(self.read_memory(addr, my_size)?)?.clone();

+ let ty = ty_of_bytes(self.read_memory(addr, my_size)?)?.clone();

let new_id = self.vtable_map.id(ty);

self.write_memory(addr, &new_id.to_le_bytes())?;

}

@@ -2049,7 +2084,7 @@ impl Evaluator<'_> {

let ty = ty.clone().substitute(Interner, subst);

self.patch_addresses(

patch_map,

- old_vtable,

+ ty_of_bytes,

addr.offset(offset),

&ty,

locals,

@@ -2071,7 +2106,7 @@ impl Evaluator<'_> {

let ty = ty.clone().substitute(Interner, subst);

self.patch_addresses(

patch_map,

- old_vtable,

+ ty_of_bytes,

addr.offset(offset),

&ty,

locals,

@@ -2084,7 +2119,7 @@ impl Evaluator<'_> {

for (id, ty) in subst.iter(Interner).enumerate() {

let ty = ty.assert_ty_ref(Interner); // Tuple only has type argument

let offset = layout.fields.offset(id).bytes_usize();

- self.patch_addresses(patch_map, old_vtable, addr.offset(offset), ty, locals)?;

+ self.patch_addresses(patch_map, ty_of_bytes, addr.offset(offset), ty, locals)?;

}

TyKind::Array(inner, len) => {

@@ -2096,7 +2131,7 @@ impl Evaluator<'_> {

for i in 0..len {

self.patch_addresses(

patch_map,

- old_vtable,

+ ty_of_bytes,

addr.offset(i * size),

inner,

locals,

@@ -2167,7 +2202,7 @@ impl Evaluator<'_> {

.map_err(|it| MirEvalError::MirLowerErrorForClosure(closure, it))?;

let closure_data = if mir_body.locals[mir_body.param_locals[0]].ty.as_reference().is_some()

{

- closure_data.addr.to_bytes()

+ closure_data.addr.to_bytes().to_vec()

} else {

closure_data.get(self)?.to_owned()

};

@@ -2553,7 +2588,7 @@ impl Evaluator<'_> {

body,

locals,

drop_fn,

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

+ iter::once(IntervalOrOwned::Owned(addr.to_bytes().to_vec())),

span,

Interval { addr: Address::Invalid(0), size: 0 },

None,

diff --git a/crates/hir-ty/src/mir/eval/tests.rs b/crates/hir-ty/src/mir/eval/tests.rs
index b0f929279a..6552bf4933 100644
--- a/crates/hir-ty/src/mir/eval/tests.rs
+++ b/crates/hir-ty/src/mir/eval/tests.rs

@@ -31,9 +31,9 @@ fn eval_main(db: &TestDB, file_id: FileId) -> Result<(String, String), MirEvalEr

db.trait_environment(func_id.into()),

)

.map_err(|e| MirEvalError::MirLowerError(func_id.into(), e))?;

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

+ let (result, output) = interpret_mir(db, body, false, None);

result?;

- Ok((stdout, stderr))

+ Ok((output.stdout().into_owned(), output.stderr().into_owned()))

}

fn check_pass(ra_fixture: &str) {

diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
index a94da818b6..947fa3c21d 100644
--- a/crates/hir-ty/src/mir/lower.rs
+++ b/crates/hir-ty/src/mir/lower.rs

@@ -1403,31 +1403,27 @@ impl<'ctx> MirLowerCtx<'ctx> {

const USIZE_SIZE: usize = mem::size_of::<usize>();

let bytes: Box<[_]> = match l {

hir_def::hir::Literal::String(b) => {

- let b = b.as_bytes();

- let mut data = Box::new([0; { 2 * USIZE_SIZE }]);

+ let mut data = [0; { 2 * USIZE_SIZE }];

data[..USIZE_SIZE].copy_from_slice(&0usize.to_le_bytes());

data[USIZE_SIZE..].copy_from_slice(&b.len().to_le_bytes());

- let mut mm = MemoryMap::default();

- mm.insert(0, b.to_vec());

- return Ok(Operand::from_concrete_const(data, mm, ty));

+ let mm = MemoryMap::simple(b.as_bytes().into());

+ return Ok(Operand::from_concrete_const(Box::new(data), mm, ty));

}

hir_def::hir::Literal::CString(b) => {

- let bytes = b.iter().copied().chain(iter::once(0)).collect::<Vec<_>>();

+ let bytes = b.iter().copied().chain(iter::once(0)).collect::<Box<_>>();

- let mut data = Box::new([0; { 2 * USIZE_SIZE }]);

+ let mut data = [0; { 2 * USIZE_SIZE }];

data[..USIZE_SIZE].copy_from_slice(&0usize.to_le_bytes());

data[USIZE_SIZE..].copy_from_slice(&bytes.len().to_le_bytes());

- let mut mm = MemoryMap::default();

- mm.insert(0, bytes);

- return Ok(Operand::from_concrete_const(data, mm, ty));

+ let mm = MemoryMap::simple(bytes);

+ return Ok(Operand::from_concrete_const(Box::new(data), mm, ty));

}

hir_def::hir::Literal::ByteString(b) => {

- let mut data = Box::new([0; { 2 * USIZE_SIZE }]);

+ let mut data = [0; { 2 * USIZE_SIZE }];

data[..USIZE_SIZE].copy_from_slice(&0usize.to_le_bytes());

data[USIZE_SIZE..].copy_from_slice(&b.len().to_le_bytes());

- let mut mm = MemoryMap::default();

- mm.insert(0, b.to_vec());

- return Ok(Operand::from_concrete_const(data, mm, ty));

+ let mm = MemoryMap::simple(b.clone());

+ return Ok(Operand::from_concrete_const(Box::new(data), mm, ty));

}

hir_def::hir::Literal::Char(c) => Box::new(u32::from(*c).to_le_bytes()),

hir_def::hir::Literal::Bool(b) => Box::new([*b as u8]),

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 4e4b758264..49f599a67a 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs

@@ -2183,7 +2183,7 @@ impl Function {

return r;

}

};

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

+ let (result, output) = interpret_mir(db, body, false, None);

let mut text = match result {

Ok(_) => "pass".to_string(),

Err(e) => {

@@ -2192,10 +2192,12 @@ impl Function {

}

};

+ let stdout = output.stdout().into_owned();

if !stdout.is_empty() {

text += "\n--------- stdout ---------\n";

text += &stdout;

}

+ let stderr = output.stdout().into_owned();

if !stderr.is_empty() {

text += "\n--------- stderr ---------\n";

text += &stderr;