mirror of https://github.com/boa-dev/boa.git
Haled Odat
1 year ago
64 changed files with 741 additions and 1576 deletions
@ -1,80 +0,0 @@ |
|||||||
use alloc::vec::Vec; |
|
||||||
|
|
||||||
use crate::interned_str::InternedStr; |
|
||||||
|
|
||||||
#[derive(Debug)] |
|
||||||
pub(super) struct FixedString<Char> { |
|
||||||
inner: Vec<Char>, |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> Default for FixedString<Char> { |
|
||||||
fn default() -> Self { |
|
||||||
Self { |
|
||||||
inner: Vec::default(), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> FixedString<Char> { |
|
||||||
/// Creates a new, pinned [`FixedString`].
|
|
||||||
pub(super) fn new(capacity: usize) -> Self { |
|
||||||
Self { |
|
||||||
inner: Vec::with_capacity(capacity), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Gets the maximum capacity of the [`FixedString`].
|
|
||||||
pub(super) fn capacity(&self) -> usize { |
|
||||||
self.inner.capacity() |
|
||||||
} |
|
||||||
|
|
||||||
/// Returns `true` if the [`FixedString`] has length zero,
|
|
||||||
/// and `false` otherwise.
|
|
||||||
pub(super) fn is_empty(&self) -> bool { |
|
||||||
self.inner.is_empty() |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> FixedString<Char> |
|
||||||
where |
|
||||||
Char: Clone, |
|
||||||
{ |
|
||||||
/// Tries to push `string` to the [`FixedString`], and returns
|
|
||||||
/// an [`InternedStr`] pointer to the stored `string`, or
|
|
||||||
/// `None` if the capacity is not enough to store `string`.
|
|
||||||
///
|
|
||||||
/// # Safety
|
|
||||||
///
|
|
||||||
/// The caller is responsible for ensuring `self` outlives the returned
|
|
||||||
/// [`InternedStr`].
|
|
||||||
pub(super) unsafe fn push(&mut self, string: &[Char]) -> Option<InternedStr<Char>> { |
|
||||||
let capacity = self.inner.capacity(); |
|
||||||
(capacity >= self.inner.len() + string.len()).then(|| { |
|
||||||
// SAFETY:
|
|
||||||
// The caller is responsible for extending the lifetime
|
|
||||||
// of `self` to outlive the return value.
|
|
||||||
unsafe { self.push_unchecked(string) } |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Pushes `string` to the [`FixedString`], and returns
|
|
||||||
/// an [`InternedStr`] pointer to the stored `string`, without
|
|
||||||
/// checking if the total `capacity` is enough to store `string`,
|
|
||||||
/// and without checking if the string is correctly aligned.
|
|
||||||
///
|
|
||||||
/// # Safety
|
|
||||||
///
|
|
||||||
/// The caller is responsible for ensuring that `self` outlives the returned
|
|
||||||
/// [`InternedStr`] and that it has enough capacity to store `string` without
|
|
||||||
/// reallocating.
|
|
||||||
pub(super) unsafe fn push_unchecked(&mut self, string: &[Char]) -> InternedStr<Char> { |
|
||||||
let old_len = self.inner.len(); |
|
||||||
self.inner.extend_from_slice(string); |
|
||||||
|
|
||||||
// SAFETY: The caller is responsible for extending the lifetime
|
|
||||||
// of `self` to outlive the return value, and for ensuring
|
|
||||||
// the alignment of `string` is correct.
|
|
||||||
let ptr = &self.inner[old_len..self.inner.len()]; |
|
||||||
unsafe { InternedStr::new(ptr.into()) } |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,80 +0,0 @@ |
|||||||
use core::{hash::Hash, ptr::NonNull}; |
|
||||||
|
|
||||||
/// Wrapper for an interned str pointer, required to
|
|
||||||
/// quickly check using a hash if a string is inside an [`Interner`][`super::Interner`].
|
|
||||||
///
|
|
||||||
/// # Safety
|
|
||||||
///
|
|
||||||
/// This struct could cause Undefined Behaviour on:
|
|
||||||
/// - Use without ensuring the referenced memory is still allocated.
|
|
||||||
/// - Construction of an [`InternedStr`] from an invalid [`NonNull<Char>`] pointer.
|
|
||||||
/// - Construction of an [`InternedStr`] from a [`NonNull<Char>`] pointer
|
|
||||||
/// without checking if the pointed memory of the [`NonNull<Char>`] outlives
|
|
||||||
/// the [`InternedStr`].
|
|
||||||
///
|
|
||||||
/// In general, this should not be used outside of an [`Interner`][`super::Interner`].
|
|
||||||
#[derive(Debug)] |
|
||||||
pub(super) struct InternedStr<Char> { |
|
||||||
ptr: NonNull<[Char]>, |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> InternedStr<Char> { |
|
||||||
/// Create a new interned string from the given `*const u8` pointer,
|
|
||||||
/// length and encoding kind
|
|
||||||
///
|
|
||||||
/// # Safety
|
|
||||||
///
|
|
||||||
/// Not maintaining the invariants specified on the struct definition
|
|
||||||
/// could cause Undefined Behaviour.
|
|
||||||
pub(super) const unsafe fn new(ptr: NonNull<[Char]>) -> Self { |
|
||||||
Self { ptr } |
|
||||||
} |
|
||||||
|
|
||||||
/// Returns a shared reference to the underlying string.
|
|
||||||
///
|
|
||||||
/// # Safety
|
|
||||||
///
|
|
||||||
/// Not maintaining the invariants specified on the struct definition
|
|
||||||
/// could cause Undefined Behaviour.
|
|
||||||
pub(super) unsafe fn as_ref(&self) -> &[Char] { |
|
||||||
// SAFETY:
|
|
||||||
// The caller must ensure `ptr` is still valid throughout the
|
|
||||||
// lifetime of `self`.
|
|
||||||
unsafe { self.ptr.as_ref() } |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> Clone for InternedStr<Char> { |
|
||||||
fn clone(&self) -> Self { |
|
||||||
*self |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> Copy for InternedStr<Char> {} |
|
||||||
|
|
||||||
impl<Char> Eq for InternedStr<Char> where Char: Eq {} |
|
||||||
|
|
||||||
impl<Char> PartialEq for InternedStr<Char> |
|
||||||
where |
|
||||||
Char: PartialEq, |
|
||||||
{ |
|
||||||
fn eq(&self, other: &Self) -> bool { |
|
||||||
// SAFETY: The caller must verify the invariants
|
|
||||||
// specified in the struct definition.
|
|
||||||
unsafe { self.as_ref() == other.as_ref() } |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> Hash for InternedStr<Char> |
|
||||||
where |
|
||||||
Char: Hash, |
|
||||||
{ |
|
||||||
fn hash<H: core::hash::Hasher>(&self, state: &mut H) { |
|
||||||
// SAFETY:
|
|
||||||
// The caller must ensure `ptr` is still valid throughout the
|
|
||||||
// lifetime of `self`.
|
|
||||||
unsafe { |
|
||||||
self.as_ref().hash(state); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,194 +0,0 @@ |
|||||||
use crate::{fixed_string::FixedString, interned_str::InternedStr}; |
|
||||||
use alloc::vec::Vec; |
|
||||||
use core::hash::{BuildHasherDefault, Hash}; |
|
||||||
use hashbrown::HashMap; |
|
||||||
use rustc_hash::FxHasher; |
|
||||||
|
|
||||||
type Map<T, U> = HashMap<T, U, BuildHasherDefault<FxHasher>>; |
|
||||||
|
|
||||||
/// Raw string interner, generic by a char type.
|
|
||||||
#[derive(Debug)] |
|
||||||
pub(super) struct RawInterner<Char> { |
|
||||||
// COMMENT FOR DEVS:
|
|
||||||
// This interner works on the assumption that
|
|
||||||
// `head` won't ever be reallocated, since this could invalidate
|
|
||||||
// some of our stored pointers inside `spans`.
|
|
||||||
// This means that any operation on `head` and `full` should be carefully
|
|
||||||
// reviewed to not cause Undefined Behaviour.
|
|
||||||
// `intern` has a more thorough explanation on this.
|
|
||||||
//
|
|
||||||
// Also, if you want to implement `shrink_to_fit` (and friends),
|
|
||||||
// please check out https://github.com/Robbepop/string-interner/pull/47 first.
|
|
||||||
// This doesn't implement that method, since implementing it increases
|
|
||||||
// our memory footprint.
|
|
||||||
symbol_cache: Map<InternedStr<Char>, usize>, |
|
||||||
spans: Vec<InternedStr<Char>>, |
|
||||||
head: FixedString<Char>, |
|
||||||
full: Vec<FixedString<Char>>, |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> Default for RawInterner<Char> { |
|
||||||
fn default() -> Self { |
|
||||||
Self { |
|
||||||
symbol_cache: Map::default(), |
|
||||||
spans: Vec::default(), |
|
||||||
head: FixedString::default(), |
|
||||||
full: Vec::default(), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> RawInterner<Char> { |
|
||||||
/// Creates a new `RawInterner` with the specified capacity.
|
|
||||||
pub(super) fn with_capacity(capacity: usize) -> Self { |
|
||||||
Self { |
|
||||||
symbol_cache: Map::default(), |
|
||||||
spans: Vec::with_capacity(capacity), |
|
||||||
head: FixedString::new(capacity), |
|
||||||
full: Vec::new(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Returns the number of strings interned by the interner.
|
|
||||||
pub(super) fn len(&self) -> usize { |
|
||||||
self.spans.len() |
|
||||||
} |
|
||||||
|
|
||||||
/// Returns `true` if the interner contains no interned strings.
|
|
||||||
pub(super) fn is_empty(&self) -> bool { |
|
||||||
self.spans.is_empty() |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> RawInterner<Char> |
|
||||||
where |
|
||||||
Char: Hash + Eq, |
|
||||||
{ |
|
||||||
/// Returns the index position for the given string if any.
|
|
||||||
///
|
|
||||||
/// Can be used to query if a string has already been interned without interning.
|
|
||||||
pub(super) fn get(&self, string: &[Char]) -> Option<usize> { |
|
||||||
// SAFETY:
|
|
||||||
// `string` is a valid slice that doesn't outlive the
|
|
||||||
// created `InternedStr`, so this is safe.
|
|
||||||
unsafe { |
|
||||||
self.symbol_cache |
|
||||||
.get(&InternedStr::new(string.into())) |
|
||||||
.copied() |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Interns the given `'static` string.
|
|
||||||
///
|
|
||||||
/// Returns the index of `string` within the interner.
|
|
||||||
///
|
|
||||||
/// # Note
|
|
||||||
///
|
|
||||||
/// This is more efficient than [`RawInterner::intern`], since it
|
|
||||||
/// avoids storing `string` inside the interner.
|
|
||||||
///
|
|
||||||
/// # Panics
|
|
||||||
///
|
|
||||||
/// If the interner already interns the maximum number of strings possible
|
|
||||||
/// by the chosen symbol type.
|
|
||||||
pub(super) fn intern_static(&mut self, string: &'static [Char]) -> usize { |
|
||||||
// SAFETY:
|
|
||||||
// A static string reference is always valid, meaning it cannot outlive
|
|
||||||
// the lifetime of the created `InternedStr`. This makes this
|
|
||||||
// operation safe.
|
|
||||||
let string = unsafe { InternedStr::new(string.into()) }; |
|
||||||
|
|
||||||
// SAFETY:
|
|
||||||
// A `InternedStr` created from a static reference
|
|
||||||
// cannot be invalidated by allocations and deallocations,
|
|
||||||
// so this is safe.
|
|
||||||
unsafe { self.next_index(string) } |
|
||||||
} |
|
||||||
|
|
||||||
/// Returns the string for the given index if any.
|
|
||||||
pub(super) fn index(&self, index: usize) -> Option<&[Char]> { |
|
||||||
self.spans.get(index).map(|ptr| |
|
||||||
// SAFETY: We always ensure the stored `InternedStr`s always
|
|
||||||
// reference memory inside `head` and `full`
|
|
||||||
unsafe {ptr.as_ref()}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Inserts a new string pointer into `spans` and returns its index.
|
|
||||||
///
|
|
||||||
/// # Safety
|
|
||||||
///
|
|
||||||
/// The caller must ensure `string` points to a valid
|
|
||||||
/// memory inside `head` (or only valid in the case of statics)
|
|
||||||
/// and that it won't be invalidated by allocations and deallocations.
|
|
||||||
unsafe fn next_index(&mut self, string: InternedStr<Char>) -> usize { |
|
||||||
let next = self.len(); |
|
||||||
self.spans.push(string); |
|
||||||
self.symbol_cache.insert(string, next); |
|
||||||
next |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl<Char> RawInterner<Char> |
|
||||||
where |
|
||||||
Char: Hash + Eq + Clone, |
|
||||||
{ |
|
||||||
/// Interns the given string.
|
|
||||||
///
|
|
||||||
/// Returns the index of `string` within the interner.
|
|
||||||
///
|
|
||||||
/// # Panics
|
|
||||||
///
|
|
||||||
/// If the interner already interns the maximum number of strings possible by the chosen symbol type.
|
|
||||||
pub(super) fn intern(&mut self, string: &[Char]) -> usize { |
|
||||||
// SAFETY:
|
|
||||||
//
|
|
||||||
// Firstly, this interner works on the assumption that the allocated
|
|
||||||
// memory by `head` won't ever be moved from its position on the heap,
|
|
||||||
// which is an important point to understand why manipulating it like
|
|
||||||
// this is safe.
|
|
||||||
//
|
|
||||||
// `String` (which is simply a `Vec<u8>` with additional invariants)
|
|
||||||
// is essentially a pointer to heap memory that can be moved without
|
|
||||||
// any problems, since copying a pointer cannot invalidate the memory
|
|
||||||
// that it points to.
|
|
||||||
//
|
|
||||||
// However, `String` CAN be invalidated when pushing, extending or
|
|
||||||
// shrinking it, since all those operations reallocate on the heap.
|
|
||||||
//
|
|
||||||
// To prevent that, we HAVE to ensure the capacity will succeed without
|
|
||||||
// having to reallocate, and the only way to do that without invalidating
|
|
||||||
// any other alive `InternedStr` is to create a brand new `head` with
|
|
||||||
// enough capacity and push the old `head` to `full` to keep it alive
|
|
||||||
// throughout the lifetime of the whole interner.
|
|
||||||
//
|
|
||||||
// `FixedString` encapsulates this by only allowing checked `push`es
|
|
||||||
// to the internal string, but we still have to ensure the memory
|
|
||||||
// of `head` is not deallocated until the whole interner deallocates,
|
|
||||||
// which we can do by moving it inside the interner itself, specifically
|
|
||||||
// on the `full` vector, where every other old `head` also lives.
|
|
||||||
let interned_str = unsafe { |
|
||||||
self.head.push(string).unwrap_or_else(|| { |
|
||||||
let new_cap = |
|
||||||
(usize::max(self.head.capacity(), string.len()) + 1).next_power_of_two(); |
|
||||||
let new_head = FixedString::new(new_cap); |
|
||||||
let old_head = core::mem::replace(&mut self.head, new_head); |
|
||||||
|
|
||||||
// If the user creates an `Interner`
|
|
||||||
// with `Interner::with_capacity(BIG_NUMBER)` and
|
|
||||||
// the first interned string's length is bigger than `BIG_NUMBER`,
|
|
||||||
// `self.full.push(old_head)` would push a big, empty string of
|
|
||||||
// allocated size `BIG_NUMBER` into `full`.
|
|
||||||
// This prevents that case.
|
|
||||||
if !old_head.is_empty() { |
|
||||||
self.full.push(old_head); |
|
||||||
} |
|
||||||
self.head.push_unchecked(string) |
|
||||||
}) |
|
||||||
}; |
|
||||||
|
|
||||||
// SAFETY: We are obtaining a pointer to the internal memory of
|
|
||||||
// `head`, which is alive through the whole life of the interner, so
|
|
||||||
// this is safe.
|
|
||||||
unsafe { self.next_index(interned_str) } |
|
||||||
} |
|
||||||
} |
|
||||||
Loading…
Reference in new issue