language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-29 23:04:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

fix roc_std to support seamless str slices

Browse source
This commit is contained in:
Brendan Hansknecht 2023-03-14 15:06:17 -07:00
parent 3978059aa2
commit 18e6dbd163
No known key found for this signature in database
GPG key ID: 0EA784685083E75B
2 changed files with 17 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

22
crates/roc_std/src/roc_list.rs
View file

@ -94,18 +94,18 @@ impl<T> RocList<T> {
}
pub fn len(&self) -> usize {
self.length
self.length & (isize::MAX as usize)
}
pub fn is_seamless_slice(&self) -> bool {
(self.capacity_or_ref_ptr as isize) < 0
((self.length | self.capacity_or_ref_ptr) as isize) < 0
}
pub fn capacity(&self) -> usize {
if !self.is_seamless_slice() {
self.capacity_or_ref_ptr
} else {
self.length
self.len()
}
}
@ -257,8 +257,10 @@ where
// Copy the old elements to the new allocation.
unsafe {
copy_nonoverlapping(elements.as_ptr(), new_elements.as_ptr(), self.length);
copy_nonoverlapping(elements.as_ptr(), new_elements.as_ptr(), self.len());
}
// Clear the seamless slice bit since we now have clear ownership.
self.length = self.len();
new_elements
}
@ -295,7 +297,7 @@ impl<T> RocList<T> {
///
/// May return a new RocList, if the provided one was not unique.
pub fn reserve(&mut self, num_elems: usize) {
let new_len = num_elems + self.length;
let new_len = num_elems + self.len();
let new_elems;
let old_elements_ptr;
@ -338,7 +340,7 @@ impl<T> RocList<T> {
unsafe {
// Copy the old elements to the new allocation.
copy_nonoverlapping(old_elements_ptr, new_elems.as_ptr(), self.length);
copy_nonoverlapping(old_elements_ptr, new_elems.as_ptr(), self.len());
}
// Decrease the current allocation's reference count.
@ -371,7 +373,7 @@ impl<T> RocList<T> {
self.update_to(Self {
elements: Some(new_elems),
length: self.length,
length: self.len(),
capacity_or_ref_ptr: new_len,
});
}
@ -392,7 +394,7 @@ impl<T> Deref for RocList<T> {
fn deref(&self) -> &Self::Target {
if let Some(elements) = self.elements {
let elements = ptr::slice_from_raw_parts(elements.as_ptr().cast::<T>(), self.length);
let elements = ptr::slice_from_raw_parts(elements.as_ptr().cast::<T>(), self.len());
unsafe { &*elements }
} else {
@ -424,7 +426,7 @@ where
{
fn partial_cmp(&self, other: &RocList<U>) -> Option<cmp::Ordering> {
// If one is longer than the other, use that as the ordering.
match self.length.partial_cmp(&other.length) {
match self.len().partial_cmp(&other.len()) {
Some(Ordering::Equal) => {}
ord => return ord,
}
@ -448,7 +450,7 @@ where
{
fn cmp(&self, other: &Self) -> Ordering {
// If one is longer than the other, use that as the ordering.
match self.length.cmp(&other.length) {
match self.len().cmp(&other.len()) {
Ordering::Equal => {}
ord => return ord,
}

5
crates/roc_std/src/roc_str.rs
View file

@ -698,6 +698,11 @@ impl From<SendSafeRocStr> for RocStr {
#[repr(C)]
union RocStrInner {
// TODO: this really should be separated from the List type.
// Due to length specifying seamless slices for Str and capacity for Lists they should not share the same code.
// Currently, there are work arounds in RocList to handle both via removing the highest bit of length in many cases.
// With glue changes, we should probably rewrite these cleanly to match what is in the zig bitcode.
// It is definitely a bit stale now and I think the storage mechanism can be quite confusing with our extra pieces of state.
heap_allocated: ManuallyDrop<RocList<u8>>,
small_string: SmallString,
}