---

yaml
---
r: 130467
b: refs/heads/try
c: 7d72bdb
h: refs/heads/master
i:
  130465: 212a36a
  130463: 0e2ff33
v: v3

Author: nrc

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c964cb229bd342bdeb0b4506c3a6d32b03e575f6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67b97ab6d2b7de9b69fd97dc171fcf8feec932ff
-refs/heads/try: 821afc4ce8367ed3d9e536925007aac5e8e3835e
+refs/heads/try: 7d72bdb226b9f7918de997e2e10315c9d9a0a62d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/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())
         }
     }
 

branches/try/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]

branches/try/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);
     }
 }
 

branches/try/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;

branches/try/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,
         _ => {}
     }

branches/try/src/libnum/complex.rs

@@ -12,13 +12,13 @@
 //! Complex numbers.
 
 use std::fmt;
-use std::num::{Zero, One, ToStrRadix};
+use std::num::{Zero,One,ToStrRadix};
 
 // FIXME #1284: handle complex NaN & infinity etc. This
 // probably doesn't map to C's _Complex correctly.
 
 /// A complex number in Cartesian form.
-#[deriving(PartialEq, Clone, Hash)]
+#[deriving(PartialEq,Clone)]
 pub struct Complex<T> {
     /// Real portion of the complex number
     pub re: T,
@@ -36,8 +36,10 @@ impl<T: Clone + Num> Complex<T> {
         Complex { re: re, im: im }
     }
 
-    /// Returns the square of the norm (since `T` doesn't necessarily
-    /// have a sqrt function), i.e. `re^2 + im^2`.
+    /**
+    Returns the square of the norm (since `T` doesn't necessarily
+    have a sqrt function), i.e. `re^2 + im^2`.
+    */
     #[inline]
     pub fn norm_sqr(&self) -> T {
         self.re * self.re + self.im * self.im
@@ -191,8 +193,7 @@ mod test {
     #![allow(non_uppercase_statics)]
 
     use super::{Complex64, Complex};
-    use std::num::{Zero, One, Float};
-    use std::hash::hash;
+    use std::num::{Zero,One,Float};
 
     pub static _0_0i : Complex64 = Complex { re: 0.0, im: 0.0 };
     pub static _1_0i : Complex64 = Complex { re: 1.0, im: 0.0 };
@@ -366,14 +367,4 @@ mod test {
         test(-_neg1_1i, "1-1i".to_string());
         test(_05_05i, "0.5+0.5i".to_string());
     }
-
-    #[test]
-    fn test_hash() {
-        let a = Complex::new(0i32, 0i32);
-        let b = Complex::new(1i32, 0i32);
-        let c = Complex::new(0i32, 1i32);
-        assert!(hash(&a) != hash(&b));
-        assert!(hash(&b) != hash(&c));
-        assert!(hash(&c) != hash(&a));
-    }
 }

branches/try/src/libnum/rational.rs

@@ -21,7 +21,7 @@ use std::num::{Zero, One, ToStrRadix, FromStrRadix};
 use bigint::{BigInt, BigUint, Sign, Plus, Minus};
 
 /// Represents the ratio between 2 numbers.
-#[deriving(Clone, Hash)]
+#[deriving(Clone)]
 #[allow(missing_doc)]
 pub struct Ratio<T> {
     numer: T,
@@ -380,7 +380,6 @@ mod test {
     use super::{Ratio, Rational, BigRational};
     use std::num::{Zero, One, FromStrRadix, FromPrimitive, ToStrRadix};
     use std::from_str::FromStr;
-    use std::hash::hash;
     use std::num;
 
     pub static _0 : Rational = Ratio { numer: 0, denom: 1};
@@ -752,10 +751,4 @@ mod test {
         assert!(! _neg1_2.is_positive());
         assert!(! _1_2.is_negative());
     }
-
-    #[test]
-    fn test_hash() {
-        assert!(hash(&_0) != hash(&_1));
-        assert!(hash(&_0) != hash(&_3_2));
-    }
 }

branches/try/src/librustc/front/test.rs

@@ -50,12 +50,10 @@ struct TestCtxt<'a> {
     path: Vec<ast::Ident>,
     ext_cx: ExtCtxt<'a>,
     testfns: Vec<Test>,
+    reexport_mod_ident: ast::Ident,
     reexport_test_harness_main: Option<InternedString>,
     is_test_crate: bool,
     config: ast::CrateConfig,
-
-    // top-level re-export submodule, filled out after folding is finished
-    toplevel_reexport: Option<ast::Ident>,
 }
 
 // Traverse the crate, collecting all the test functions, eliding any
@@ -85,9 +83,7 @@ pub fn modify_for_testing(sess: &Session,
 struct TestHarnessGenerator<'a> {
     cx: TestCtxt<'a>,
     tests: Vec<ast::Ident>,
-
-    // submodule name, gensym'd identifier for re-exports
-    tested_submods: Vec<(ast::Ident, ast::Ident)>,
+    tested_submods: Vec<ast::Ident>,
 }
 
 impl<'a> fold::Folder for TestHarnessGenerator<'a> {
@@ -172,14 +168,10 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
             *i = nomain(*i);
         }
         if !tests.is_empty() || !tested_submods.is_empty() {
-            let (it, sym) = mk_reexport_mod(&mut self.cx, tests, tested_submods);
-            mod_folded.items.push(it);
-
+            mod_folded.items.push(mk_reexport_mod(&mut self.cx, tests,
+                                                  tested_submods));
             if !self.cx.path.is_empty() {
-                self.tested_submods.push((self.cx.path[self.cx.path.len()-1], sym));
-            } else {
-                debug!("pushing nothing, sym: {}", sym);
-                self.cx.toplevel_reexport = Some(sym);
+                self.tested_submods.push(self.cx.path[self.cx.path.len()-1]);
             }
         }
 
@@ -188,16 +180,16 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
 }
 
 fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>,
-                   tested_submods: Vec<(ast::Ident, ast::Ident)>) -> (Gc<ast::Item>, ast::Ident) {
+                   tested_submods: Vec<ast::Ident>) -> Gc<ast::Item> {
     let mut view_items = Vec::new();
     let super_ = token::str_to_ident("super");
 
     view_items.extend(tests.move_iter().map(|r| {
         cx.ext_cx.view_use_simple(DUMMY_SP, ast::Public,
                                   cx.ext_cx.path(DUMMY_SP, vec![super_, r]))
     }));
-    view_items.extend(tested_submods.move_iter().map(|(r, sym)| {
-        let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, sym]);
+    view_items.extend(tested_submods.move_iter().map(|r| {
+        let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, cx.reexport_mod_ident]);
         cx.ext_cx.view_use_simple_(DUMMY_SP, ast::Public, r, path)
     }));
 
@@ -206,18 +198,14 @@ fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>,
         view_items: view_items,
         items: Vec::new(),
     };
-
-    let sym = token::gensym_ident("__test_reexports");
-    let it = box(GC) ast::Item {
-        ident: sym.clone(),
+    box(GC) ast::Item {
+        ident: cx.reexport_mod_ident.clone(),
         attrs: Vec::new(),
         id: ast::DUMMY_NODE_ID,
         node: ast::ItemMod(reexport_mod),
         vis: ast::Public,
         span: DUMMY_SP,
-    };
-
-    (it, sym)
+    }
 }
 
 fn generate_test_harness(sess: &Session,
@@ -232,10 +220,10 @@ fn generate_test_harness(sess: &Session,
                              }),
         path: Vec::new(),
         testfns: Vec::new(),
+        reexport_mod_ident: token::gensym_ident("__test_reexports"),
         reexport_test_harness_main: reexport_test_harness_main,
         is_test_crate: is_test_crate(&krate),
         config: krate.config.clone(),
-        toplevel_reexport: None,
     };
 
     cx.ext_cx.bt_push(ExpnInfo {
@@ -542,14 +530,7 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> Gc<ast::Expr> {
              field("should_fail", fail_expr)]);
 
 
-    let mut visible_path = match cx.toplevel_reexport {
-        Some(id) => vec![id],
-        None => {
-            cx.sess.bug(
-                "expected to find top-level re-export name, but found None"
-            );
-        }
-    };
+    let mut visible_path = vec![cx.reexport_mod_ident.clone()];
     visible_path.extend(path.move_iter());
 
     let fn_expr = ecx.expr_path(ecx.path_global(span, visible_path));