---

yaml
---
r: 130077
b: refs/heads/snap-stage3
c: e9bd650
h: refs/heads/master
i:
  130075: 4891e13
v: v3

Author: nrc

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 0bdac78da87605f6f7f6e7924872617226b19c85
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2e385817926f6f914fbff482aab3a8b627e7feee
+refs/heads/snap-stage3: e9bd650cad7c519e3f39b8bbed5afeac94daff05
 refs/heads/try: 28d5878c1f0465c11c8e7a3085008b0c592d48d0
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/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/snap-stage3/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/snap-stage3/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));

branches/snap-stage3/src/librustc/middle/trans/datum.rs

@@ -451,6 +451,8 @@ impl Datum<Expr> {
                                name: &str,
                                expr_id: ast::NodeId)
                                -> DatumBlock<'a, Lvalue> {
+        debug!("to_lvalue_datum self: {}", self.to_string(bcx.ccx()));
+
         assert!(ty::lltype_is_sized(bcx.tcx(), self.ty),
                 "Trying to convert unsized value to lval");
         self.match_kind(

branches/snap-stage3/src/librustc/middle/trans/expr.rs

@@ -2061,11 +2061,17 @@ fn deref_once<'a>(bcx: &'a Block<'a>,
             if ty::type_is_sized(bcx.tcx(), content_ty) {
                 deref_owned_pointer(bcx, expr, datum, content_ty)
             } else {
-                // A fat pointer and an opened DST value have the same represenation
-                // just different types.
-                DatumBlock::new(bcx, Datum::new(datum.val,
-                                                ty::mk_open(bcx.tcx(), content_ty),
-                                                datum.kind))
+                // A fat pointer and an opened DST value have the same
+                // represenation just different types. Since there is no
+                // temporary for `*e` here (because it is unsized), we cannot
+                // emulate the sized object code path for running drop glue and
+                // free. Instead, we schedule cleanup for `e`, turning it into
+                // an lvalue.
+                let datum = unpack_datum!(
+                    bcx, datum.to_lvalue_datum(bcx, "deref", expr.id));
+
+                let datum = Datum::new(datum.val, ty::mk_open(bcx.tcx(), content_ty), LvalueExpr);
+                DatumBlock::new(bcx, datum)
             }
         }
 
@@ -2094,7 +2100,7 @@ fn deref_once<'a>(bcx: &'a Block<'a>,
                 // just different types.
                 DatumBlock::new(bcx, Datum::new(datum.val,
                                                 ty::mk_open(bcx.tcx(), content_ty),
-                                                datum.kind))
+                                                LvalueExpr))
             }
         }
 

branches/snap-stage3/src/test/debuginfo/gdb-pretty-struct-and-enums-pre-gdb-7-7.rs

@@ -12,7 +12,6 @@
 // older versions of GDB too. A more extensive test can be found in
 // gdb-pretty-struct-and-enums.rs
 
-// ignore-test FIXME(#16919)
 // ignore-tidy-linelength
 // ignore-lldb
 // ignore-android: FIXME(#10381)

branches/snap-stage3/src/test/debuginfo/gdb-pretty-struct-and-enums.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-test FIXME(#16919)
 // ignore-tidy-linelength
 // ignore-lldb
 // ignore-android: FIXME(#10381)

branches/snap-stage3/src/test/run-pass/issue-16597-empty.rs

@@ -8,11 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-macos osx really doesn't like cycling through large numbers of
-//              sockets as calls to connect() will start returning EADDRNOTAVAIL
-//              quite quickly and it takes a few seconds for the sockets to get
-//              recycled.
-
 #![feature(phase)]
 
 #[phase(plugin)]
@@ -25,7 +20,7 @@ use std::task::TaskBuilder;
 use native::NativeTaskBuilder;
 
 static N: uint = 8;
-static M: uint = 20;
+static M: uint = 100;
 
 green_start!(main)
 
@@ -45,12 +40,11 @@ fn test() {
     let mut a = l.listen().unwrap();
     let cnt = Arc::new(atomic::AtomicUint::new(0));
 
-    let (srv_tx, srv_rx) = channel();
-    let (cli_tx, cli_rx) = channel();
+    let (tx, rx) = channel();
     for _ in range(0, N) {
         let a = a.clone();
         let cnt = cnt.clone();
-        let srv_tx = srv_tx.clone();
+        let tx = tx.clone();
         spawn(proc() {
             let mut a = a;
             loop {
@@ -64,36 +58,33 @@ fn test() {
                     Err(e) => fail!("{}", e),
                 }
             }
-            srv_tx.send(());
+            tx.send(());
         });
     }
 
     for _ in range(0, N) {
-        let cli_tx = cli_tx.clone();
+        let tx = tx.clone();
         spawn(proc() {
             for _ in range(0, M) {
                 let _s = TcpStream::connect(addr.ip.to_string().as_slice(),
                                             addr.port).unwrap();
             }
-            cli_tx.send(());
+            tx.send(());
         });
     }
-    drop((cli_tx, srv_tx));
+    drop(tx);
 
     // wait for senders
-    if cli_rx.iter().take(N).count() != N {
-        a.close_accept().unwrap();
-        fail!("clients failed");
-    }
+    assert_eq!(rx.iter().take(N).count(), N);
 
     // wait for one acceptor to die
-    let _ = srv_rx.recv();
+    let _ = rx.recv();
 
     // Notify other receivers should die
     a.close_accept().unwrap();
 
     // wait for receivers
-    assert_eq!(srv_rx.iter().take(N - 1).count(), N - 1);
+    assert_eq!(rx.iter().take(N - 1).count(), N - 1);
 
     // Everything should have been accepted.
     assert_eq!(cnt.load(atomic::SeqCst), N * M);