---

yaml
---
r: 72171
b: refs/heads/dist-snap
c: 5c2e9b2
h: refs/heads/master
i:
  72169: d04cd53
  72167: 841f12f
v: v3

Author: huonw

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 047ba2642f39baa60c13aa0318ddcb09d9ca5301
+refs/heads/dist-snap: 5c2e9b29f10694ad76dcb6b88e95243a44813c05
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/tutorial.md

@@ -1670,7 +1670,7 @@ do spawn {
 ~~~~
 
 If you want to see the output of `debug!` statements, you will need to turn on `debug!` logging.
-To enable `debug!` logging, set the RUST_LOG environment variable to the name of your crate, which, for a file named `foo.rs`, will be `foo` (e.g., with bash, `export RUST_LOG=foo`).
+To enable `debug!` logging, set the RUST_LOG environment variable to `debug` (e.g., with bash, `export RUST_LOG=debug`)
 
 ## For loops
 

branches/dist-snap/src/libcore/sys.rs

@@ -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 {