---

yaml
---
r: 130174
b: refs/heads/master
c: d90921a
h: refs/heads/master
v: v3

Author: nodakai

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5924937a5a6d59baabb4f3d94b1cf5b2bf2136eb
+refs/heads/master: d90921a9d87b17df5eeab9e5f18581e8b04a1ba9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67b97ab6d2b7de9b69fd97dc171fcf8feec932ff
 refs/heads/try: 28d5878c1f0465c11c8e7a3085008b0c592d48d0

trunk/src/libcollections/bitv.rs

@@ -95,6 +95,20 @@ fn match_words <'a,'b>(a: &'a Bitv, b: &'b Bitv) -> (MatchWords<'a>, MatchWords<
 static TRUE: bool = true;
 static FALSE: bool = false;
 
+#[deriving(Clone)]
+struct SmallBitv {
+    /// only the lowest nbits of this value are used. the rest is undefined.
+    bits: uint
+}
+
+#[deriving(Clone)]
+struct BigBitv {
+    storage: Vec<uint>
+}
+
+#[deriving(Clone)]
+enum BitvVariant { Big(BigBitv), Small(SmallBitv) }
+
 /// The bitvector type.
 ///
 /// # Example
@@ -1639,7 +1653,6 @@ impl<'a> Iterator<uint> for TwoBitPositions<'a> {
 #[cfg(test)]
 mod tests {
     use std::prelude::*;
-    use std::iter::range_step;
     use std::uint;
     use std::rand;
     use std::rand::Rng;
@@ -2033,14 +2046,12 @@ mod tests {
 
     #[test]
     fn test_bitv_iterator() {
-        let bools = vec![true, false, true, true];
+        let bools = [true, false, true, true];
         let bitv: Bitv = bools.iter().map(|n| *n).collect();
 
-        assert_eq!(bitv.iter().collect::<Vec<bool>>(), bools)
-
-        let long = Vec::from_fn(10000, |i| i % 2 == 0);
-        let bitv: Bitv = long.iter().map(|n| *n).collect();
-        assert_eq!(bitv.iter().collect::<Vec<bool>>(), long)
+        for (act, &ex) in bitv.iter().zip(bools.iter()) {
+            assert_eq!(ex, act);
+        }
     }
 
     #[test]
@@ -2050,12 +2061,6 @@ mod tests {
 
         let idxs: Vec<uint> = bitv.iter().collect();
         assert_eq!(idxs, vec!(0, 2, 3));
-
-        let long: BitvSet = range(0u, 10000).map(|n| n % 2 == 0).collect();
-        let real = range_step(0, 10000, 2).collect::<Vec<uint>>();
-
-        let idxs: Vec<uint> = long.iter().collect();
-        assert_eq!(idxs, real);
     }
 
     #[test]
@@ -2569,7 +2574,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_set_big_fixed(b: &mut Bencher) {
+    fn bench_bitv_big(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
@@ -2581,19 +2586,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_set_big_variable(b: &mut Bencher) {
-        let mut r = rng();
-        let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
-        b.iter(|| {
-            for i in range(0u, 100) {
-                bitv.set((r.next_u32() as uint) % BENCH_BITS, r.gen());
-            }
-            &bitv
-        })
-    }
-
-    #[bench]
-    fn bench_bitv_set_small(b: &mut Bencher) {
+    fn bench_bitv_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(uint::BITS, false);
         b.iter(|| {
@@ -2605,7 +2598,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitvset_small(b: &mut Bencher) {
+    fn bench_bitv_set_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
@@ -2617,7 +2610,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitvset_big(b: &mut Bencher) {
+    fn bench_bitv_set_big(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {

trunk/src/libcollections/dlist.rs

@@ -90,7 +90,7 @@ impl<T> Rawlink<T> {
     /// Convert the `Rawlink` into an Option value
     fn resolve_immut<'a>(&self) -> Option<&'a T> {
         unsafe {
-            self.p.as_ref()
+            mem::transmute(self.p.to_option())
         }
     }
 

trunk/src/libcore/ptr.rs

@@ -256,46 +256,27 @@ pub unsafe fn position<T>(buf: *const T, f: |&T| -> bool) -> uint {
 pub trait RawPtr<T> {
     /// Returns the null pointer.
     fn null() -> Self;
-
     /// Returns true if the pointer is equal to the null pointer.
     fn is_null(&self) -> bool;
-
     /// Returns true if the pointer is not equal to the null pointer.
     fn is_not_null(&self) -> bool { !self.is_null() }
-
     /// Returns the value of this pointer (ie, the address it points to)
     fn to_uint(&self) -> uint;
-
-    /// Returns `None` if the pointer is null, or else returns a reference to the
-    /// value wrapped in `Some`.
+    /// Returns `None` if the pointer is null, or else returns the value wrapped
+    /// in `Some`.
     ///
     /// # Safety Notes
     ///
-    /// While this method and its mutable counterpart are useful for null-safety,
-    /// it is important to note that this is still an unsafe operation because
-    /// the returned value could be pointing to invalid memory.
-    unsafe fn as_ref<'a>(&self) -> Option<&'a T>;
-
-    /// A synonym for `as_ref`, except with incorrect lifetime semantics
-    #[deprecated="Use `as_ref` instead"]
-    unsafe fn to_option<'a>(&'a self) -> Option<&'a T> {
-        mem::transmute(self.as_ref())
-    }
-
+    /// While this method is useful for null-safety, it is important to note
+    /// that this is still an unsafe operation because the returned value could
+    /// be pointing to invalid memory.
+    unsafe fn to_option(&self) -> Option<&T>;
     /// Calculates the offset from a pointer. The offset *must* be in-bounds of
     /// the object, or one-byte-past-the-end.  `count` is in units of T; e.g. a
     /// `count` of 3 represents a pointer offset of `3 * sizeof::<T>()` bytes.
     unsafe fn offset(self, count: int) -> Self;
 }
 
-/// Methods on mutable raw pointers
-pub trait RawMutPtr<T>{
-    /// Returns `None` if the pointer is null, or else returns a mutable reference
-    /// to the value wrapped in `Some`. As with `as_ref`, this is unsafe because
-    /// it cannot verify the validity of the returned pointer.
-    unsafe fn as_mut<'a>(&self) -> Option<&'a mut T>;
-}
-
 impl<T> RawPtr<T> for *const T {
     #[inline]
     fn null() -> *const T { null() }
@@ -312,7 +293,7 @@ impl<T> RawPtr<T> for *const T {
     }
 
     #[inline]
-    unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
+    unsafe fn to_option(&self) -> Option<&T> {
         if self.is_null() {
             None
         } else {
@@ -337,7 +318,7 @@ impl<T> RawPtr<T> for *mut T {
     }
 
     #[inline]
-    unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
+    unsafe fn to_option(&self) -> Option<&T> {
         if self.is_null() {
             None
         } else {
@@ -346,17 +327,6 @@ impl<T> RawPtr<T> for *mut T {
     }
 }
 
-impl<T> RawMutPtr<T> for *mut T {
-    #[inline]
-    unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> {
-        if self.is_null() {
-            None
-        } else {
-            Some(&mut **self)
-        }
-    }
-}
-
 // Equality for pointers
 impl<T> PartialEq for *const T {
     #[inline]

trunk/src/libcoretest/ptr.rs

@@ -102,44 +102,19 @@ fn test_is_null() {
 }
 
 #[test]
-fn test_as_ref() {
+fn test_to_option() {
     unsafe {
         let p: *const int = null();
-        assert_eq!(p.as_ref(), None);
+        assert_eq!(p.to_option(), None);
 
         let q: *const int = &2;
-        assert_eq!(q.as_ref().unwrap(), &2);
+        assert_eq!(q.to_option().unwrap(), &2);
 
         let p: *mut int = mut_null();
-        assert_eq!(p.as_ref(), None);
+        assert_eq!(p.to_option(), None);
 
         let q: *mut int = &mut 2;
-        assert_eq!(q.as_ref().unwrap(), &2);
-
-        // Lifetime inference
-        let u = 2i;
-        {
-            let p: *const int = &u as *const _;
-            assert_eq!(p.as_ref().unwrap(), &2);
-        }
-    }
-}
-
-#[test]
-fn test_as_mut() {
-    unsafe {
-        let p: *mut int = mut_null();
-        assert!(p.as_mut() == None);
-
-        let q: *mut int = &mut 2;
-        assert!(q.as_mut().unwrap() == &mut 2);
-
-        // Lifetime inference
-        let mut u = 2i;
-        {
-            let p: *mut int = &mut u as *mut _;
-            assert!(p.as_mut().unwrap() == &mut 2);
-        }
+        assert_eq!(q.to_option().unwrap(), &2);
     }
 }
 

trunk/src/liblibc/lib.rs

@@ -2965,14 +2965,12 @@ pub mod consts {
             pub static AF_INET6: c_int = 10;
             pub static SOCK_STREAM: c_int = 2;
             pub static SOCK_DGRAM: c_int = 1;
-            pub static SOCK_RAW: c_int = 3;
             pub static IPPROTO_TCP: c_int = 6;
             pub static IPPROTO_IP: c_int = 0;
             pub static IPPROTO_IPV6: c_int = 41;
             pub static IP_MULTICAST_TTL: c_int = 33;
             pub static IP_MULTICAST_LOOP: c_int = 34;
             pub static IP_TTL: c_int = 2;
-            pub static IP_HDRINCL: c_int = 3;
             pub static IP_ADD_MEMBERSHIP: c_int = 35;
             pub static IP_DROP_MEMBERSHIP: c_int = 36;
             pub static IPV6_ADD_MEMBERSHIP: c_int = 20;
@@ -3023,12 +3021,8 @@ pub mod consts {
         pub mod extra {
             use types::os::arch::c95::c_int;
 
-            pub static AF_PACKET : c_int = 17;
-            pub static IPPROTO_RAW : c_int = 255;
-
             pub static O_RSYNC : c_int = 16400;
             pub static O_DSYNC : c_int = 16;
-            pub static O_NONBLOCK : c_int = 128;
             pub static O_SYNC : c_int = 16400;
 
             pub static PROT_GROWSDOWN : c_int = 0x01000000;

trunk/src/liblog/lib.rs

@@ -282,7 +282,7 @@ impl Drop for DefaultLogger {
 pub fn log(level: u32, loc: &'static LogLocation, args: &fmt::Arguments) {
     // Test the literal string from args against the current filter, if there
     // is one.
-    match unsafe { FILTER.as_ref() } {
+    match unsafe { FILTER.to_option() } {
         Some(filter) if filter.is_match(args.to_string().as_slice()) => return,
         _ => {}
     }