language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-08-04 18:58:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

refactor: Replace custom ThinVec with thin-vec crate

Browse source
This commit is contained in:
Lukas Wirth 2025-03-24 13:43:47 +01:00
parent dd2354c985
commit dcd742301e
15 changed files with 99 additions and 543 deletions
Download patch file Download diff file Expand all files Collapse all files

7
Cargo.lock generated
View file

@ -651,6 +651,7 @@ dependencies = [
"test-fixture",
"test-utils",
"text-size",
"thin-vec",
"tracing",
"triomphe",
"tt",
@ -2330,6 +2331,12 @@ version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f18aa187839b2bdb1ad2fa35ead8c4c2976b64e4363c386d45ac0f7ee85c9233"
[[package]]
name = "thin-vec"
version = "0.2.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "144f754d318415ac792f9d69fc87abbbfc043ce2ef041c60f16ad828f638717d"
[[package]]
name = "thiserror"
version = "1.0.69"

1
crates/hir-def/Cargo.toml
View file

@ -43,6 +43,7 @@ mbe.workspace = true
cfg.workspace = true
tt.workspace = true
span.workspace = true
thin-vec = "0.2.14"
[dev-dependencies]
expect-test.workspace = true

31
crates/hir-def/src/generics.rs
View file

@ -12,11 +12,9 @@ use hir_expand::{
};
use intern::sym;
use la_arena::{Arena, RawIdx};
use stdx::{
impl_from,
thin_vec::{EmptyOptimizedThinVec, ThinVec},
};
use stdx::impl_from;
use syntax::ast::{self, HasGenericParams, HasName, HasTypeBounds};
use thin_vec::ThinVec;
use triomphe::Arc;
use crate::{
@ -753,12 +751,17 @@ fn copy_type_ref(
) -> TypeRefId {
let result = match &from[type_ref] {
TypeRef::Fn(fn_) => {
let params = fn_.params().iter().map(|(name, param_type)| {
let params = fn_.params.iter().map(|(name, param_type)| {
(name.clone(), copy_type_ref(*param_type, from, from_source_map, to, to_source_map))
});
TypeRef::Fn(FnType::new(fn_.is_varargs(), fn_.is_unsafe(), fn_.abi().clone(), params))
TypeRef::Fn(Box::new(FnType {
params: params.collect(),
is_varargs: fn_.is_varargs,
is_unsafe: fn_.is_unsafe,
abi: fn_.abi.clone(),
}))
}
TypeRef::Tuple(types) => TypeRef::Tuple(EmptyOptimizedThinVec::from_iter(
TypeRef::Tuple(types) => TypeRef::Tuple(ThinVec::from_iter(
types.iter().map(|&t| copy_type_ref(t, from, from_source_map, to, to_source_map)),
)),
&TypeRef::RawPtr(type_ref, mutbl) => TypeRef::RawPtr(
@ -817,13 +820,17 @@ fn copy_path(
Path::BarePath(mod_path) => Path::BarePath(mod_path.clone()),
Path::Normal(path) => {
let type_anchor = path
.type_anchor()
.type_anchor
.map(|type_ref| copy_type_ref(type_ref, from, from_source_map, to, to_source_map));
let mod_path = path.mod_path().clone();
let generic_args = path.generic_args().iter().map(|generic_args| {
let mod_path = path.mod_path.clone();
let generic_args = path.generic_args.iter().map(|generic_args| {
copy_generic_args(generic_args, from, from_source_map, to, to_source_map)
});
Path::Normal(NormalPath::new(type_anchor, mod_path, generic_args))
Path::Normal(Box::new(NormalPath {
generic_args: generic_args.collect(),
type_anchor,
mod_path,
}))
}
Path::LangItem(lang_item, name) => Path::LangItem(*lang_item, name.clone()),
}
@ -879,7 +886,7 @@ fn copy_type_bounds<'a>(
from_source_map: &'a TypesSourceMap,
to: &'a mut TypesMap,
to_source_map: &'a mut TypesSourceMap,
) -> impl stdx::thin_vec::TrustedLen<Item = TypeBound> + 'a {
) -> impl Iterator<Item = TypeBound> + 'a {
bounds.iter().map(|bound| copy_type_bound(bound, from, from_source_map, to, to_source_map))
}

36
crates/hir-def/src/hir/type_ref.rs
View file

@ -12,11 +12,11 @@ use hir_expand::{
use intern::{Symbol, sym};
use la_arena::{Arena, ArenaMap, Idx};
use span::Edition;
use stdx::thin_vec::{EmptyOptimizedThinVec, ThinVec, thin_vec_with_header_struct};
use syntax::{
AstPtr,
ast::{self, HasGenericArgs, HasName, IsString},
};
use thin_vec::ThinVec;
use crate::{
SyntheticSyntax,
@ -120,13 +120,12 @@ impl TraitRef {
}
}
thin_vec_with_header_struct! {
pub new(pub(crate)) struct FnType, FnTypeHeader {
pub params: [(Option<Name>, TypeRefId)],
pub is_varargs: bool,
pub is_unsafe: bool,
pub abi: Option<Symbol>; ref,
}
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub struct FnType {
pub params: Box<[(Option<Name>, TypeRefId)]>,
pub is_varargs: bool,
pub is_unsafe: bool,
pub abi: Option<Symbol>,
}
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
@ -148,14 +147,14 @@ pub struct RefType {
pub enum TypeRef {
Never,
Placeholder,
Tuple(EmptyOptimizedThinVec<TypeRefId>),
Tuple(ThinVec<TypeRefId>),
Path(Path),
RawPtr(TypeRefId, Mutability),
Reference(Box<RefType>),
Array(Box<ArrayType>),
Slice(TypeRefId),
/// A fn pointer. Last element of the vector is the return type.
Fn(FnType),
Fn(Box<FnType>),
ImplTrait(ThinVec<TypeBound>),
DynTrait(ThinVec<TypeBound>),
Macro(AstId<ast::MacroCall>),
@ -273,9 +272,9 @@ impl TypeRef {
pub fn from_ast(ctx: &mut LowerCtx<'_>, node: ast::Type) -> TypeRefId {
let ty = match &node {
ast::Type::ParenType(inner) => return TypeRef::from_ast_opt(ctx, inner.ty()),
ast::Type::TupleType(inner) => TypeRef::Tuple(EmptyOptimizedThinVec::from_iter(
Vec::from_iter(inner.fields().map(|it| TypeRef::from_ast(ctx, it))),
)),
ast::Type::TupleType(inner) => TypeRef::Tuple(ThinVec::from_iter(Vec::from_iter(
inner.fields().map(|it| TypeRef::from_ast(ctx, it)),
))),
ast::Type::NeverType(..) => TypeRef::Never,
ast::Type::PathType(inner) => {
// FIXME: Use `Path::from_src`
@ -342,7 +341,12 @@ impl TypeRef {
let abi = inner.abi().map(lower_abi);
params.push((None, ret_ty));
TypeRef::Fn(FnType::new(is_varargs, inner.unsafe_token().is_some(), abi, params))
TypeRef::Fn(Box::new(FnType {
params: params.into(),
is_varargs,
is_unsafe: inner.unsafe_token().is_some(),
abi,
}))
}
// for types are close enough for our purposes to the inner type for now...
ast::Type::ForType(inner) => return TypeRef::from_ast_opt(ctx, inner.ty()),
@ -375,7 +379,7 @@ impl TypeRef {
}
pub(crate) fn unit() -> TypeRef {
TypeRef::Tuple(EmptyOptimizedThinVec::empty())
TypeRef::Tuple(ThinVec::new())
}
pub fn walk(this: TypeRefId, map: &TypesMap, f: &mut impl FnMut(&TypeRef)) {
@ -386,7 +390,7 @@ impl TypeRef {
f(type_ref);
match type_ref {
TypeRef::Fn(fn_) => {
fn_.params().iter().for_each(|&(_, param_type)| go(param_type, f, map))
fn_.params.iter().for_each(|&(_, param_type)| go(param_type, f, map))
}
TypeRef::Tuple(types) => types.iter().for_each(|&t| go(t, f, map)),
TypeRef::RawPtr(type_ref, _) | TypeRef::Slice(type_ref) => go(*type_ref, f, map),

2
crates/hir-def/src/item_tree/lower.rs
View file

@ -12,11 +12,11 @@ use intern::{Symbol, sym};
use la_arena::Arena;
use rustc_hash::FxHashMap;
use span::{AstIdMap, SyntaxContext};
use stdx::thin_vec::ThinVec;
use syntax::{
AstNode,
ast::{self, HasModuleItem, HasName, HasTypeBounds, IsString},
};
use thin_vec::ThinVec;
use triomphe::Arc;
use crate::{

2
crates/hir-def/src/lower.rs
View file

@ -3,8 +3,8 @@ use std::{cell::OnceCell, mem};
use hir_expand::{AstId, HirFileId, InFile, span_map::SpanMap};
use span::{AstIdMap, AstIdNode, Edition, EditionedFileId, FileId, RealSpanMap};
use stdx::thin_vec::ThinVec;
use syntax::ast;
use thin_vec::ThinVec;
use triomphe::Arc;
use crate::{

52
crates/hir-def/src/path.rs
View file

@ -16,7 +16,6 @@ use crate::{
use hir_expand::name::Name;
use intern::Interned;
use span::Edition;
use stdx::thin_vec::thin_vec_with_header_struct;
use syntax::ast;
pub use hir_expand::mod_path::{ModPath, PathKind, path};
@ -58,7 +57,7 @@ pub enum Path {
/// this is not a problem since many more paths have generics than a type anchor).
BarePath(Interned<ModPath>),
/// `Path::Normal` will always have either generics or type anchor.
Normal(NormalPath),
Normal(Box<NormalPath>),
/// A link to a lang item. It is used in desugaring of things like `it?`. We can show these
/// links via a normal path since they might be private and not accessible in the usage place.
LangItem(LangItemTarget, Option<Name>),
@ -71,12 +70,11 @@ const _: () = {
assert!(size_of::<Option<Path>>() == 16);
};
thin_vec_with_header_struct! {
pub new(pub(crate)) struct NormalPath, NormalPathHeader {
pub generic_args: [Option<GenericArgs>],
pub type_anchor: Option<TypeRefId>,
pub mod_path: Interned<ModPath>; ref,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct NormalPath {
pub generic_args: Box<[Option<GenericArgs>]>,
pub type_anchor: Option<TypeRefId>,
pub mod_path: Interned<ModPath>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@ -143,7 +141,11 @@ impl Path {
/// Converts a known mod path to `Path`.
pub fn from_known_path(path: ModPath, generic_args: Vec<Option<GenericArgs>>) -> Path {
Path::Normal(NormalPath::new(None, Interned::new(path), generic_args))
Path::Normal(Box::new(NormalPath {
generic_args: generic_args.into_boxed_slice(),
type_anchor: None,
mod_path: Interned::new(path),
}))
}
/// Converts a known mod path to `Path`.
@ -155,7 +157,7 @@ impl Path {
pub fn kind(&self) -> &PathKind {
match self {
Path::BarePath(mod_path) => &mod_path.kind,
Path::Normal(path) => &path.mod_path().kind,
Path::Normal(path) => &path.mod_path.kind,
Path::LangItem(..) => &PathKind::Abs,
}
}
@ -163,7 +165,7 @@ impl Path {
#[inline]
pub fn type_anchor(&self) -> Option<TypeRefId> {
match self {
Path::Normal(path) => path.type_anchor(),
Path::Normal(path) => path.type_anchor,
Path::LangItem(..) | Path::BarePath(_) => None,
}
}
@ -171,7 +173,7 @@ impl Path {
#[inline]
pub fn generic_args(&self) -> Option<&[Option<GenericArgs>]> {
match self {
Path::Normal(path) => Some(path.generic_args()),
Path::Normal(path) => Some(&path.generic_args),
Path::LangItem(..) | Path::BarePath(_) => None,
}
}
@ -182,8 +184,8 @@ impl Path {
PathSegments { segments: mod_path.segments(), generic_args: None }
}
Path::Normal(path) => PathSegments {
segments: path.mod_path().segments(),
generic_args: Some(path.generic_args()),
segments: path.mod_path.segments(),
generic_args: Some(&path.generic_args),
},
Path::LangItem(_, seg) => PathSegments { segments: seg.as_slice(), generic_args: None },
}
@ -192,7 +194,7 @@ impl Path {
pub fn mod_path(&self) -> Option<&ModPath> {
match self {
Path::BarePath(mod_path) => Some(mod_path),
Path::Normal(path) => Some(path.mod_path()),
Path::Normal(path) => Some(&path.mod_path),
Path::LangItem(..) => None,
}
}
@ -209,12 +211,12 @@ impl Path {
))))
}
Path::Normal(path) => {
let mod_path = path.mod_path();
let mod_path = &path.mod_path;
if mod_path.is_ident() {
return None;
}
let type_anchor = path.type_anchor();
let generic_args = path.generic_args();
let type_anchor = path.type_anchor;
let generic_args = &path.generic_args;
let qualifier_mod_path = Interned::new(ModPath::from_segments(
mod_path.kind,
mod_path.segments()[..mod_path.segments().len() - 1].iter().cloned(),
@ -223,11 +225,11 @@ impl Path {
if type_anchor.is_none() && qualifier_generic_args.iter().all(|it| it.is_none()) {
Some(Path::BarePath(qualifier_mod_path))
} else {
Some(Path::Normal(NormalPath::new(
Some(Path::Normal(Box::new(NormalPath {
type_anchor,
qualifier_mod_path,
qualifier_generic_args.iter().cloned(),
)))
mod_path: qualifier_mod_path,
generic_args: qualifier_generic_args.iter().cloned().collect(),
})))
}
}
Path::LangItem(..) => None,
@ -238,9 +240,9 @@ impl Path {
match self {
Path::BarePath(mod_path) => mod_path.is_Self(),
Path::Normal(path) => {
path.type_anchor().is_none()
&& path.mod_path().is_Self()
&& path.generic_args().iter().all(|args| args.is_none())
path.type_anchor.is_none()
&& path.mod_path.is_Self()
&& path.generic_args.iter().all(|args| args.is_none())
}
Path::LangItem(..) => false,
}

10
crates/hir-def/src/path/lower.rs
View file

@ -9,8 +9,8 @@ use hir_expand::{
name::{AsName, Name},
};
use intern::{Interned, sym};
use stdx::thin_vec::EmptyOptimizedThinVec;
use syntax::ast::{self, AstNode, HasGenericArgs, HasTypeBounds};
use thin_vec::ThinVec;
use crate::{
path::{
@ -213,7 +213,11 @@ pub(super) fn lower_path(ctx: &mut LowerCtx<'_>, mut path: ast::Path) -> Option<
if type_anchor.is_none() && generic_args.is_empty() {
return Some(Path::BarePath(mod_path));
} else {
return Some(Path::Normal(NormalPath::new(type_anchor, mod_path, generic_args)));
return Some(Path::Normal(Box::new(NormalPath {
generic_args: generic_args.into_boxed_slice(),
type_anchor,
mod_path,
})));
}
fn qualifier(path: &ast::Path) -> Option<ast::Path> {
@ -344,7 +348,7 @@ fn lower_generic_args_from_fn_path(
param_types.push(type_ref);
}
let args = Box::new([GenericArg::Type(
ctx.alloc_type_ref_desugared(TypeRef::Tuple(EmptyOptimizedThinVec::from_iter(param_types))),
ctx.alloc_type_ref_desugared(TypeRef::Tuple(ThinVec::from_iter(param_types))),
)]);
let bindings = if let Some(ret_type) = ret_type {
let type_ref = TypeRef::from_ast_opt(ctx, ret_type.ty());

8
crates/hir-def/src/pretty.rs
View file

@ -220,11 +220,11 @@ pub(crate) fn print_type_ref(
}
TypeRef::Fn(fn_) => {
let ((_, return_type), args) =
fn_.params().split_last().expect("TypeRef::Fn is missing return type");
if fn_.is_unsafe() {
fn_.params.split_last().expect("TypeRef::Fn is missing return type");
if fn_.is_unsafe {
write!(buf, "unsafe ")?;
}
if let Some(abi) = fn_.abi() {
if let Some(abi) = &fn_.abi {
buf.write_str("extern ")?;
buf.write_str(abi.as_str())?;
buf.write_char(' ')?;
@ -236,7 +236,7 @@ pub(crate) fn print_type_ref(
}
print_type_ref(db, *typeref, map, buf, edition)?;
}
if fn_.is_varargs() {
if fn_.is_varargs {
if !args.is_empty() {
write!(buf, ", ")?;
}

4
crates/hir-def/src/resolver.rs
View file

@ -181,7 +181,7 @@ impl Resolver {
{
let path = match path {
Path::BarePath(mod_path) => mod_path,
Path::Normal(it) => it.mod_path(),
Path::Normal(it) => &it.mod_path,
Path::LangItem(l, seg) => {
let type_ns = match *l {
LangItemTarget::Union(it) => TypeNs::AdtId(it.into()),
@ -304,7 +304,7 @@ impl Resolver {
) -> Option<(ResolveValueResult, ResolvePathResultPrefixInfo)> {
let path = match path {
Path::BarePath(mod_path) => mod_path,
Path::Normal(it) => it.mod_path(),
Path::Normal(it) => &it.mod_path,
Path::LangItem(l, None) => {
return Some((
ResolveValueResult::ValueNs(

10
crates/hir-ty/src/display.rs
View file

@ -2128,16 +2128,16 @@ impl HirDisplayWithTypesMap for TypeRefId {
write!(f, "]")?;
}
TypeRef::Fn(fn_) => {
if fn_.is_unsafe() {
if fn_.is_unsafe {
write!(f, "unsafe ")?;
}
if let Some(abi) = fn_.abi() {
if let Some(abi) = &fn_.abi {
f.write_str("extern \"")?;
f.write_str(abi.as_str())?;
f.write_str("\" ")?;
}
write!(f, "fn(")?;
if let Some(((_, return_type), function_parameters)) = fn_.params().split_last() {
if let Some(((_, return_type), function_parameters)) = fn_.params.split_last() {
for index in 0..function_parameters.len() {
let (param_name, param_type) = &function_parameters[index];
if let Some(name) = param_name {
@ -2150,8 +2150,8 @@ impl HirDisplayWithTypesMap for TypeRefId {
write!(f, ", ")?;
}
}
if fn_.is_varargs() {
write!(f, "{}...", if fn_.params().len() == 1 { "" } else { ", " })?;
if fn_.is_varargs {
write!(f, "{}...", if fn_.params.len() == 1 { "" } else { ", " })?;
}
write!(f, ")")?;
match &types_map[*return_type] {

2
crates/hir-ty/src/infer/expr.rs
View file

@ -198,7 +198,7 @@ impl InferenceContext<'_> {
match &self.body[expr] {
// Lang item paths cannot currently be local variables or statics.
Expr::Path(Path::LangItem(_, _)) => false,
Expr::Path(Path::Normal(path)) => path.type_anchor().is_none(),
Expr::Path(Path::Normal(path)) => path.type_anchor.is_none(),
Expr::Path(path) => self
.resolver
.resolve_path_in_value_ns_fully(

8
crates/hir-ty/src/lower.rs
View file

@ -318,15 +318,15 @@ impl<'a> TyLoweringContext<'a> {
let substs = self.with_shifted_in(DebruijnIndex::ONE, |ctx| {
Substitution::from_iter(
Interner,
fn_.params().iter().map(|&(_, tr)| ctx.lower_ty(tr)),
fn_.params.iter().map(|&(_, tr)| ctx.lower_ty(tr)),
)
});
TyKind::Function(FnPointer {
num_binders: 0, // FIXME lower `for<'a> fn()` correctly
sig: FnSig {
abi: fn_.abi().as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),
safety: if fn_.is_unsafe() { Safety::Unsafe } else { Safety::Safe },
variadic: fn_.is_varargs(),
abi: fn_.abi.as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),
safety: if fn_.is_unsafe { Safety::Unsafe } else { Safety::Safe },
variadic: fn_.is_varargs,
},
substitution: FnSubst(substs),
})

1
crates/stdx/src/lib.rs
View file

@ -12,7 +12,6 @@ pub mod non_empty_vec;
pub mod panic_context;
pub mod process;
pub mod rand;
pub mod thin_vec;
pub mod thread;
pub use itertools;

468
crates/stdx/src/thin_vec.rs
View file

@ -1,468 +0,0 @@
use std::alloc::{Layout, dealloc, handle_alloc_error};
use std::fmt;
use std::hash::{Hash, Hasher};
use std::marker::PhantomData;
use std::ops::{Deref, DerefMut};
use std::ptr::{NonNull, addr_of_mut, slice_from_raw_parts_mut};
/// A type that is functionally equivalent to `(Header, Box<[Item]>)`,
/// but all data is stored in one heap allocation and the pointer is thin,
/// so the whole thing's size is like a pointer.
pub struct ThinVecWithHeader<Header, Item> {
/// INVARIANT: Points to a valid heap allocation that contains `ThinVecInner<Header>`,
/// followed by (suitably aligned) `len` `Item`s.
ptr: NonNull<ThinVecInner<Header>>,
_marker: PhantomData<(Header, Box<[Item]>)>,
}
// SAFETY: We essentially own both the header and the items.
unsafe impl<Header: Send, Item: Send> Send for ThinVecWithHeader<Header, Item> {}
unsafe impl<Header: Sync, Item: Sync> Sync for ThinVecWithHeader<Header, Item> {}
#[derive(Clone)]
struct ThinVecInner<Header> {
header: Header,
len: usize,
}
impl<Header, Item> ThinVecWithHeader<Header, Item> {
/// # Safety
///
/// The iterator must produce `len` elements.
#[inline]
unsafe fn from_trusted_len_iter(
header: Header,
len: usize,
items: impl Iterator<Item = Item>,
) -> Self {
let (ptr, layout, items_offset) = Self::allocate(len);
struct DeallocGuard(*mut u8, Layout);
impl Drop for DeallocGuard {
fn drop(&mut self) {
// SAFETY: We allocated this above.
unsafe {
dealloc(self.0, self.1);
}
}
}
let _dealloc_guard = DeallocGuard(ptr.as_ptr().cast::<u8>(), layout);
// INVARIANT: Between `0..1` there are only initialized items.
struct ItemsGuard<Item>(*mut Item, *mut Item);
impl<Item> Drop for ItemsGuard<Item> {
fn drop(&mut self) {
// SAFETY: Our invariant.
unsafe {
slice_from_raw_parts_mut(self.0, self.1.offset_from(self.0) as usize)
.drop_in_place();
}
}
}
// SAFETY: We allocated enough space.
let mut items_ptr = unsafe { ptr.as_ptr().byte_add(items_offset).cast::<Item>() };
// INVARIANT: There are zero elements in this range.
let mut items_guard = ItemsGuard(items_ptr, items_ptr);
items.for_each(|item| {
// SAFETY: Our precondition guarantee we won't get more than `len` items, and we allocated
// enough space for `len` items.
unsafe {
items_ptr.write(item);
items_ptr = items_ptr.add(1);
}
// INVARIANT: We just initialized this item.
items_guard.1 = items_ptr;
});
// SAFETY: We allocated enough space.
unsafe {
ptr.write(ThinVecInner { header, len });
}
std::mem::forget(items_guard);
std::mem::forget(_dealloc_guard);
// INVARIANT: We allocated and initialized all fields correctly.
Self { ptr, _marker: PhantomData }
}
#[inline]
fn allocate(len: usize) -> (NonNull<ThinVecInner<Header>>, Layout, usize) {
let (layout, items_offset) = Self::layout(len);
// SAFETY: We always have `len`, so our allocation cannot be zero-sized.
let ptr = unsafe { std::alloc::alloc(layout).cast::<ThinVecInner<Header>>() };
let Some(ptr) = NonNull::<ThinVecInner<Header>>::new(ptr) else {
handle_alloc_error(layout);
};
(ptr, layout, items_offset)
}
#[inline]
#[allow(clippy::should_implement_trait)]
pub fn from_iter<I>(header: Header, items: I) -> Self
where
I: IntoIterator,
I::IntoIter: TrustedLen<Item = Item>,
{
let items = items.into_iter();
// SAFETY: `TrustedLen` guarantees the iterator length is exact.
unsafe { Self::from_trusted_len_iter(header, items.len(), items) }
}
#[inline]
fn items_offset(&self) -> usize {
// SAFETY: We `pad_to_align()` in `layout()`, so at most where accessing past the end of the allocation,
// which is allowed.
unsafe {
Layout::new::<ThinVecInner<Header>>().extend(Layout::new::<Item>()).unwrap_unchecked().1
}
}
#[inline]
fn header_and_len(&self) -> &ThinVecInner<Header> {
// SAFETY: By `ptr`'s invariant, it is correctly allocated and initialized.
unsafe { &*self.ptr.as_ptr() }
}
#[inline]
fn items_ptr(&self) -> *mut [Item] {
let len = self.header_and_len().len;
// SAFETY: `items_offset()` returns the correct offset of the items, where they are allocated.
let ptr = unsafe { self.ptr.as_ptr().byte_add(self.items_offset()).cast::<Item>() };
slice_from_raw_parts_mut(ptr, len)
}
#[inline]
pub fn header(&self) -> &Header {
&self.header_and_len().header
}
#[inline]
pub fn header_mut(&mut self) -> &mut Header {
// SAFETY: By `ptr`'s invariant, it is correctly allocated and initialized.
unsafe { &mut *addr_of_mut!((*self.ptr.as_ptr()).header) }
}
#[inline]
pub fn items(&self) -> &[Item] {
// SAFETY: `items_ptr()` gives a valid pointer.
unsafe { &*self.items_ptr() }
}
#[inline]
pub fn items_mut(&mut self) -> &mut [Item] {
// SAFETY: `items_ptr()` gives a valid pointer.
unsafe { &mut *self.items_ptr() }
}
#[inline]
pub fn len(&self) -> usize {
self.header_and_len().len
}
#[inline]
fn layout(len: usize) -> (Layout, usize) {
let (layout, items_offset) = Layout::new::<ThinVecInner<Header>>()
.extend(Layout::array::<Item>(len).expect("too big `ThinVec` requested"))
.expect("too big `ThinVec` requested");
let layout = layout.pad_to_align();
(layout, items_offset)
}
}
/// # Safety
///
/// The length reported must be exactly the number of items yielded.
pub unsafe trait TrustedLen: ExactSizeIterator {}
unsafe impl<T> TrustedLen for std::vec::IntoIter<T> {}
unsafe impl<T> TrustedLen for std::slice::Iter<'_, T> {}
unsafe impl<'a, T: Clone + 'a, I: TrustedLen<Item = &'a T>> TrustedLen for std::iter::Cloned<I> {}
unsafe impl<T, I: TrustedLen, F: FnMut(I::Item) -> T> TrustedLen for std::iter::Map<I, F> {}
unsafe impl<T> TrustedLen for std::vec::Drain<'_, T> {}
unsafe impl<T, const N: usize> TrustedLen for std::array::IntoIter<T, N> {}
impl<Header: Clone, Item: Clone> Clone for ThinVecWithHeader<Header, Item> {
#[inline]
fn clone(&self) -> Self {
Self::from_iter(self.header().clone(), self.items().iter().cloned())
}
}
impl<Header, Item> Drop for ThinVecWithHeader<Header, Item> {
#[inline]
fn drop(&mut self) {
// This must come before we drop `header`, because after that we cannot make a reference to it in `len()`.
let len = self.len();
// SAFETY: The contents are allocated and initialized.
unsafe {
addr_of_mut!((*self.ptr.as_ptr()).header).drop_in_place();
self.items_ptr().drop_in_place();
}
let (layout, _) = Self::layout(len);
// SAFETY: This was allocated in `new()` with the same layout calculation.
unsafe {
dealloc(self.ptr.as_ptr().cast::<u8>(), layout);
}
}
}
impl<Header: fmt::Debug, Item: fmt::Debug> fmt::Debug for ThinVecWithHeader<Header, Item> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ThinVecWithHeader")
.field("header", self.header())
.field("items", &self.items())
.finish()
}
}
impl<Header: PartialEq, Item: PartialEq> PartialEq for ThinVecWithHeader<Header, Item> {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.header() == other.header() && self.items() == other.items()
}
}
impl<Header: Eq, Item: Eq> Eq for ThinVecWithHeader<Header, Item> {}
impl<Header: Hash, Item: Hash> Hash for ThinVecWithHeader<Header, Item> {
#[inline]
fn hash<H: Hasher>(&self, state: &mut H) {
self.header().hash(state);
self.items().hash(state);
}
}
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct ThinVec<T>(ThinVecWithHeader<(), T>);
impl<T> ThinVec<T> {
#[inline]
#[allow(clippy::should_implement_trait)]
pub fn from_iter<I>(values: I) -> Self
where
I: IntoIterator,
I::IntoIter: TrustedLen<Item = T>,
{
Self(ThinVecWithHeader::from_iter((), values))
}
#[inline]
pub fn len(&self) -> usize {
self.0.len()
}
#[inline]
pub fn iter(&self) -> std::slice::Iter<'_, T> {
(**self).iter()
}
#[inline]
pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
(**self).iter_mut()
}
}
impl<T> Deref for ThinVec<T> {
type Target = [T];
#[inline]
fn deref(&self) -> &Self::Target {
self.0.items()
}
}
impl<T> DerefMut for ThinVec<T> {
#[inline]
fn deref_mut(&mut self) -> &mut Self::Target {
self.0.items_mut()
}
}
impl<'a, T> IntoIterator for &'a ThinVec<T> {
type IntoIter = std::slice::Iter<'a, T>;
type Item = &'a T;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
impl<'a, T> IntoIterator for &'a mut ThinVec<T> {
type IntoIter = std::slice::IterMut<'a, T>;
type Item = &'a mut T;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.iter_mut()
}
}
impl<T: fmt::Debug> fmt::Debug for ThinVec<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(&**self).finish()
}
}
/// A [`ThinVec`] that requires no allocation for the empty case.
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct EmptyOptimizedThinVec<T>(Option<ThinVec<T>>);
impl<T> EmptyOptimizedThinVec<T> {
#[inline]
#[allow(clippy::should_implement_trait)]
pub fn from_iter<I>(values: I) -> Self
where
I: IntoIterator,
I::IntoIter: TrustedLen<Item = T>,
{
let values = values.into_iter();
if values.len() == 0 { Self::empty() } else { Self(Some(ThinVec::from_iter(values))) }
}
#[inline]
pub fn empty() -> Self {
Self(None)
}
#[inline]
pub fn len(&self) -> usize {
self.0.as_ref().map_or(0, ThinVec::len)
}
#[inline]
pub fn iter(&self) -> std::slice::Iter<'_, T> {
(**self).iter()
}
#[inline]
pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
(**self).iter_mut()
}
}
impl<T> Default for EmptyOptimizedThinVec<T> {
#[inline]
fn default() -> Self {
Self::empty()
}
}
impl<T> Deref for EmptyOptimizedThinVec<T> {
type Target = [T];
#[inline]
fn deref(&self) -> &Self::Target {
self.0.as_deref().unwrap_or_default()
}
}
impl<T> DerefMut for EmptyOptimizedThinVec<T> {
#[inline]
fn deref_mut(&mut self) -> &mut Self::Target {
self.0.as_deref_mut().unwrap_or_default()
}
}
impl<'a, T> IntoIterator for &'a EmptyOptimizedThinVec<T> {
type IntoIter = std::slice::Iter<'a, T>;
type Item = &'a T;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
impl<'a, T> IntoIterator for &'a mut EmptyOptimizedThinVec<T> {
type IntoIter = std::slice::IterMut<'a, T>;
type Item = &'a mut T;
#[inline]
fn into_iter(self) -> Self::IntoIter {
self.iter_mut()
}
}
impl<T: fmt::Debug> fmt::Debug for EmptyOptimizedThinVec<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(&**self).finish()
}
}
/// Syntax:
///
/// ```ignore
/// thin_vec_with_header_struct! {
/// pub new(pub(crate)) struct MyCoolStruct, MyCoolStructHeader {
/// pub(crate) variable_length: [Ty],
/// pub field1: CopyTy,
/// pub field2: NonCopyTy; ref,
/// }
/// }
/// ```
#[doc(hidden)]
#[macro_export]
macro_rules! thin_vec_with_header_struct_ {
(@maybe_ref (ref) $($t:tt)*) => { &$($t)* };
(@maybe_ref () $($t:tt)*) => { $($t)* };
(
$vis:vis new($new_vis:vis) struct $struct:ident, $header:ident {
$items_vis:vis $items:ident : [$items_ty:ty],
$( $header_var_vis:vis $header_var:ident : $header_var_ty:ty $(; $ref:ident)?, )+
}
) => {
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
struct $header {
$( $header_var : $header_var_ty, )+
}
#[derive(Clone, Eq, PartialEq, Hash)]
$vis struct $struct($crate::thin_vec::ThinVecWithHeader<$header, $items_ty>);
impl $struct {
#[inline]
#[allow(unused)]
$new_vis fn new<I>(
$( $header_var: $header_var_ty, )+
$items: I,
) -> Self
where
I: ::std::iter::IntoIterator,
I::IntoIter: $crate::thin_vec::TrustedLen<Item = $items_ty>,
{
Self($crate::thin_vec::ThinVecWithHeader::from_iter(
$header { $( $header_var, )+ },
$items,
))
}
#[inline]
$items_vis fn $items(&self) -> &[$items_ty] {
self.0.items()
}
$(
#[inline]
$header_var_vis fn $header_var(&self) -> $crate::thin_vec_with_header_struct_!(@maybe_ref ($($ref)?) $header_var_ty) {
$crate::thin_vec_with_header_struct_!(@maybe_ref ($($ref)?) self.0.header().$header_var)
}
)+
}
impl ::std::fmt::Debug for $struct {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.debug_struct(stringify!($struct))
$( .field(stringify!($header_var), &self.$header_var()) )*
.field(stringify!($items), &self.$items())
.finish()
}
}
};
}
pub use crate::thin_vec_with_header_struct_ as thin_vec_with_header_struct;