libcore: wrappers for size/align_of to act on values without needing explicit ::<type> annotations

This commit is contained in:
Huon Wilson 2013-04-20 14:34:18 +10:00
parent 8b3c09a103
commit 5c2e9b29f1

View File

@ -83,12 +83,24 @@ pub fn get_type_desc<T>() -> *TypeDesc {
unsafe { rusti::get_tydesc::<T>() as *TypeDesc }
}
/// Returns a pointer to a type descriptor.
#[inline(always)]
pub fn get_type_desc_val<T>(_val: &T) -> *TypeDesc {
get_type_desc::<T>()
}
/// Returns the size of a type
#[inline(always)]
pub fn size_of<T>() -> uint {
unsafe { rusti::size_of::<T>() }
}
/// Returns the size of the type that `_val` points to
#[inline(always)]
pub fn size_of_val<T>(_val: &T) -> uint {
size_of::<T>()
}
/**
* Returns the size of a type, or 1 if the actual size is zero.
*
@ -100,6 +112,13 @@ pub fn nonzero_size_of<T>() -> uint {
if s == 0 { 1 } else { s }
}
/// Returns the size of the type of the value that `_val` points to
#[inline(always)]
pub fn nonzero_size_of_val<T>(_val: &T) -> uint {
nonzero_size_of::<T>()
}
/**
* Returns the ABI-required minimum alignment of a type
*
@ -111,12 +130,26 @@ pub fn min_align_of<T>() -> uint {
unsafe { rusti::min_align_of::<T>() }
}
/// Returns the ABI-required minimum alignment of the type of the value that
/// `_val` points to
#[inline(always)]
pub fn min_align_of_val<T>(_val: &T) -> uint {
min_align_of::<T>()
}
/// Returns the preferred alignment of a type
#[inline(always)]
pub fn pref_align_of<T>() -> uint {
unsafe { rusti::pref_align_of::<T>() }
}
/// Returns the preferred alignment of the type of the value that
/// `_val` points to
#[inline(always)]
pub fn pref_align_of_val<T>(_val: &T) -> uint {
pref_align_of::<T>()
}
/// Returns the refcount of a shared box (as just before calling this)
#[inline(always)]
pub fn refcount<T>(t: @T) -> uint {
@ -162,7 +195,7 @@ pub fn fail_assert(msg: &str, file: &str, line: uint) -> ! {
#[cfg(test)]
mod tests {
use cast;
use sys::{Closure, pref_align_of, size_of, nonzero_size_of};
use sys::*;
#[test]
fn size_of_basic() {
@ -188,6 +221,14 @@ mod tests {
assert!(size_of::<*uint>() == 8u);
}
#[test]
fn size_of_val_basic() {
assert_eq!(size_of_val(&1u8), 1);
assert_eq!(size_of_val(&1u16), 2);
assert_eq!(size_of_val(&1u32), 4);
assert_eq!(size_of_val(&1u64), 8);
}
#[test]
fn nonzero_size_of_basic() {
type Z = [i8, ..0];
@ -196,6 +237,14 @@ mod tests {
assert!(nonzero_size_of::<uint>() == size_of::<uint>());
}
#[test]
fn nonzero_size_of_val_basic() {
let z = [0u8, ..0];
assert_eq!(size_of_val(&z), 0u);
assert_eq!(nonzero_size_of_val(&z), 1u);
assert_eq!(nonzero_size_of_val(&1u), size_of_val(&1u));
}
#[test]
fn align_of_basic() {
assert!(pref_align_of::<u8>() == 1u);
@ -219,6 +268,13 @@ mod tests {
assert!(pref_align_of::<*uint>() == 8u);
}
#[test]
fn align_of_val_basic() {
assert_eq!(pref_align_of_val(&1u8), 1u);
assert_eq!(pref_align_of_val(&1u16), 2u);
assert_eq!(pref_align_of_val(&1u32), 4u);
}
#[test]
fn synthesize_closure() {
unsafe {