---

yaml
---
r: 93814
b: refs/heads/try
c: efe9d74
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: 09ed7913e43cf0234a1bbe3f29dcd52c6a166961
+refs/heads/try: efe9d744f986e762fe4d309298be38723ef260fb
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/tutorial.md

@@ -1320,8 +1320,7 @@ let z = x; // this moves `x` into `z`, rather than creating a new owner
 
 assert_eq!(*z.borrow(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
-// the variable is mutable, but not the contents of the box
-let mut a = Rc::new([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
+let mut a = Rc::new([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]); // the variable is mutable, but not the box
 a = z;
 ~~~
 

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

@@ -141,9 +141,11 @@ impl Visitor<()> for Context {
             },
             ast::ty_box(_) => {
                 self.gate_feature("managed_boxes", t.span,
-                                  "The managed box syntax is being replaced by the `std::gc::Gc`
-                                  and `std::rc::Rc` types. Equivalent functionality to managed
-                                  trait objects will be implemented but is currently missing.");
+                                  "The managed box syntax will be replaced \
+                                  by a library type, and a garbage \
+                                  collector is not yet implemented. \
+                                  Consider using the `std::rc::Rc` type \
+                                  for reference counted pointers.");
             }
             _ => {}
         }

branches/try/src/librustc/middle/privacy.rs

@@ -22,7 +22,7 @@ use middle::privacy;
 use std::hashmap::HashSet;
 use syntax::ast;
 use syntax::ast_map;
-use syntax::ast_util::{def_id_of_def, is_local};
+use syntax::ast_util::{def_id_of_def, is_local, local_def};
 use syntax::attr;
 use syntax::parse::token;
 use syntax::visit::Visitor;
@@ -310,13 +310,47 @@ impl ReachableContext {
                         }
                     }
 
+                    // Implementations of exported structs/enums need to get
+                    // added to the worklist (as all their methods should be
+                    // accessible)
+                    ast::item_struct(*) | ast::item_enum(*) => {
+                        let def = local_def(item.id);
+                        let impls = match self.tcx.inherent_impls.find(&def) {
+                            Some(&impls) => impls,
+                            None => return
+                        };
+                        for imp in impls.iter() {
+                            if is_local(imp.did) {
+                                self.worklist.push(imp.did.node);
+                            }
+                        }
+                    }
+
+                    // Propagate through this impl
+                    ast::item_impl(_, _, _, ref methods) => {
+                        for method in methods.iter() {
+                            self.worklist.push(method.id);
+                        }
+                    }
+
+                    // Default methods of exported traits need to all be
+                    // accessible.
+                    ast::item_trait(_, _, ref methods) => {
+                        for method in methods.iter() {
+                            match *method {
+                                ast::required(*) => {}
+                                ast::provided(ref method) => {
+                                    self.worklist.push(method.id);
+                                }
+                            }
+                        }
+                    }
+
                     // These are normal, nothing reachable about these
                     // inherently and their children are already in the
-                    // worklist, as determined by the privacy pass
+                    // worklist
                     ast::item_static(*) | ast::item_ty(*) |
-                    ast::item_mod(*) | ast::item_foreign_mod(*) |
-                    ast::item_impl(*) | ast::item_trait(*) |
-                    ast::item_struct(*) | ast::item_enum(*) => {}
+                        ast::item_mod(*) | ast::item_foreign_mod(*) => {}
 
                     _ => {
                         self.tcx.sess.span_bug(item.span,

branches/try/src/librustc/middle/reachable.rs

@@ -2759,7 +2759,6 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<&'static str, ValueRef> {
          [i8p, Type::i8(), Type::i64(), Type::i32(), Type::i1()], Type::void());
 
     ifn!(intrinsics, "llvm.trap", [], Type::void());
-    ifn!(intrinsics, "llvm.debugtrap", [], Type::void());
     ifn!(intrinsics, "llvm.frameaddress", [Type::i32()], i8p);
 
     ifn!(intrinsics, "llvm.powi.f32", [Type::f32(), Type::i32()], Type::f32());

branches/try/src/librustc/middle/trans/base.rs

@@ -228,11 +228,6 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
             Call(bcx, llfn, [], []);
             Unreachable(bcx);
         }
-        "breakpoint" => {
-            let llfn = bcx.ccx().intrinsics.get_copy(&("llvm.debugtrap"));
-            Call(bcx, llfn, [], []);
-            RetVoid(bcx);
-        }
         "size_of" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);

branches/try/src/librustc/middle/trans/intrinsic.rs

@@ -3968,8 +3968,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
 
     } else {
         match name {
-            "abort" => (0, ~[], ty::mk_bot()),
-            "breakpoint" => (0, ~[], ty::mk_nil()),
+            "abort"  => (0, ~[], ty::mk_bot()),
             "size_of" |
             "pref_align_of" | "min_align_of" => (1u, ~[], ty::mk_uint()),
             "init" => (1u, ~[], param(ccx, 0u)),

branches/try/src/librustc/middle/typeck/check/mod.rs

@@ -444,17 +444,17 @@ mod tests {
     fn test_rand_sample() {
         let mut rand_sample = RandSample::<ConstRand>;
 
-        assert_eq!(*rand_sample.sample(&mut task_rng()), 0);
-        assert_eq!(*rand_sample.ind_sample(&mut task_rng()), 0);
+        assert_eq!(*rand_sample.sample(task_rng()), 0);
+        assert_eq!(*rand_sample.ind_sample(task_rng()), 0);
     }
 
     #[test]
     fn test_normal() {
         let mut norm = Normal::new(10.0, 10.0);
-        let mut rng = task_rng();
+        let rng = task_rng();
         for _ in range(0, 1000) {
-            norm.sample(&mut rng);
-            norm.ind_sample(&mut rng);
+            norm.sample(rng);
+            norm.ind_sample(rng);
         }
     }
     #[test]
@@ -466,10 +466,10 @@ mod tests {
     #[test]
     fn test_exp() {
         let mut exp = Exp::new(10.0);
-        let mut rng = task_rng();
+        let rng = task_rng();
         for _ in range(0, 1000) {
-            assert!(exp.sample(&mut rng) >= 0.0);
-            assert!(exp.ind_sample(&mut rng) >= 0.0);
+            assert!(exp.sample(rng) >= 0.0);
+            assert!(exp.ind_sample(rng) >= 0.0);
         }
     }
     #[test]

branches/try/src/libstd/rand/distributions/mod.rs

@@ -183,7 +183,7 @@ mod tests {
 
     #[test]
     fn test_integers() {
-        let mut rng = task_rng();
+        let rng = task_rng();
         macro_rules! t (
             ($($ty:ty),*) => {{
                 $(
@@ -193,9 +193,9 @@ mod tests {
                    for &(low, high) in v.iter() {
                         let mut sampler: Range<$ty> = Range::new(low, high);
                         for _ in range(0, 1000) {
-                            let v = sampler.sample(&mut rng);
+                            let v = sampler.sample(rng);
                             assert!(low <= v && v < high);
-                            let v = sampler.ind_sample(&mut rng);
+                            let v = sampler.ind_sample(rng);
                             assert!(low <= v && v < high);
                         }
                     }
@@ -208,7 +208,7 @@ mod tests {
 
     #[test]
     fn test_floats() {
-        let mut rng = task_rng();
+        let rng = task_rng();
         macro_rules! t (
             ($($ty:ty),*) => {{
                 $(
@@ -219,9 +219,9 @@ mod tests {
                    for &(low, high) in v.iter() {
                         let mut sampler: Range<$ty> = Range::new(low, high);
                         for _ in range(0, 1000) {
-                            let v = sampler.sample(&mut rng);
+                            let v = sampler.sample(rng);
                             assert!(low <= v && v < high);
-                            let v = sampler.ind_sample(&mut rng);
+                            let v = sampler.ind_sample(rng);
                             assert!(low <= v && v < high);
                         }
                     }

branches/try/src/libstd/rand/distributions/range.rs

@@ -577,24 +577,11 @@ impl reseeding::Reseeder<StdRng> for TaskRngReseeder {
     }
 }
 static TASK_RNG_RESEED_THRESHOLD: uint = 32_768;
-type TaskRngInner = reseeding::ReseedingRng<StdRng, TaskRngReseeder>;
 /// The task-local RNG.
-#[no_send]
-pub struct TaskRng {
-    // This points into TLS (specifically, it points to the endpoint
-    // of a ~ stored in TLS, to make it robust against TLS moving
-    // things internally) and so this struct cannot be legally
-    // transferred between tasks *and* it's unsafe to deallocate the
-    // RNG other than when a task is finished.
-    //
-    // The use of unsafe code here is OK if the invariants above are
-    // satisfied; and it allows us to avoid (unnecessarily) using a
-    // GC'd or RC'd pointer.
-    priv rng: *mut TaskRngInner
-}
+pub type TaskRng = reseeding::ReseedingRng<StdRng, TaskRngReseeder>;
 
 // used to make space in TLS for a random number generator
-local_data_key!(TASK_RNG_KEY: ~TaskRngInner)
+local_data_key!(TASK_RNG_KEY: @mut TaskRng)
 
 /// Retrieve the lazily-initialized task-local random number
 /// generator, seeded by the system. Intended to be used in method
@@ -607,34 +594,34 @@ local_data_key!(TASK_RNG_KEY: ~TaskRngInner)
 /// if the operating system random number generator is rigged to give
 /// the same sequence always. If absolute consistency is required,
 /// explicitly select an RNG, e.g. `IsaacRng` or `Isaac64Rng`.
-pub fn task_rng() -> TaskRng {
-    local_data::get_mut(TASK_RNG_KEY, |rng| match rng {
+pub fn task_rng() -> @mut TaskRng {
+    let r = local_data::get(TASK_RNG_KEY, |k| k.map(|k| *k));
+    match r {
         None => {
-            let mut rng = ~reseeding::ReseedingRng::new(StdRng::new(),
+            let rng = @mut reseeding::ReseedingRng::new(StdRng::new(),
                                                         TASK_RNG_RESEED_THRESHOLD,
                                                         TaskRngReseeder);
-            let ptr = &mut *rng as *mut TaskRngInner;
-
             local_data::set(TASK_RNG_KEY, rng);
-
-            TaskRng { rng: ptr }
+            rng
         }
-        Some(rng) => TaskRng { rng: &mut **rng }
-    })
+        Some(rng) => rng
+    }
 }
 
-impl Rng for TaskRng {
+// Allow direct chaining with `task_rng`
+impl<R: Rng> Rng for @mut R {
+    #[inline]
     fn next_u32(&mut self) -> u32 {
-        unsafe { (*self.rng).next_u32() }
+        (**self).next_u32()
     }
-
+    #[inline]
     fn next_u64(&mut self) -> u64 {
-        unsafe { (*self.rng).next_u64() }
+        (**self).next_u64()
     }
 
     #[inline]
     fn fill_bytes(&mut self, bytes: &mut [u8]) {
-        unsafe { (*self.rng).fill_bytes(bytes) }
+        (**self).fill_bytes(bytes);
     }
 }
 

branches/try/src/libstd/rand/mod.rs

@@ -20,6 +20,7 @@ extern {
 #[inline]
 pub fn get_box_size(body_size: uint, body_align: uint) -> uint {
     let header_size = size_of::<raw::Box<()>>();
+    // FIXME (#2699): This alignment calculation is suspicious. Is it right?
     let total_size = align_to(header_size, body_align) + body_size;
     total_size
 }

branches/try/src/libstd/rt/global_heap.rs

@@ -176,10 +176,6 @@ extern "rust-intrinsic" {
     /// Abort the execution of the process.
     pub fn abort() -> !;
 
-    /// Execute a breakpoint trap, for inspection by a debugger.
-    #[cfg(not(stage0))]
-    pub fn breakpoint();
-
     /// Atomic compare and exchange, sequentially consistent.
     pub fn atomic_cxchg(dst: &mut int, old: int, src: int) -> int;
     /// Atomic compare and exchange, acquire ordering.

branches/try/src/libstd/unstable/intrinsics.rs

@@ -3862,10 +3862,10 @@ mod bench {
     }
 
     #[bench]
-    fn add(bh: &mut BenchHarness) {
+    fn add(b: &mut BenchHarness) {
         let xs: &[int] = [5, ..10];
         let ys: &[int] = [5, ..10];
-        do bh.iter() {
+        do b.iter() {
             xs + ys;
         }
     }
@@ -3885,72 +3885,4 @@ mod bench {
             xss.connect_vec(&0);
         }
     }
-
-    #[bench]
-    fn push(bh: &mut BenchHarness) {
-        let mut vec: ~[uint] = ~[0u];
-        do bh.iter() {
-            vec.push(0);
-        }
-    }
-
-    #[bench]
-    fn starts_with_same_vector(bh: &mut BenchHarness) {
-        let vec: ~[uint] = vec::from_fn(100, |i| i);
-        do bh.iter() {
-            vec.starts_with(vec);
-        }
-    }
-
-    #[bench]
-    fn starts_with_single_element(bh: &mut BenchHarness) {
-        let vec: ~[uint] = ~[0u];
-        do bh.iter() {
-            vec.starts_with(vec);
-        }
-    }
-
-    #[bench]
-    fn starts_with_diff_one_element_at_end(bh: &mut BenchHarness) {
-        let vec: ~[uint] = vec::from_fn(100, |i| i);
-        let mut match_vec: ~[uint] = vec::from_fn(99, |i| i);
-        match_vec.push(0);
-        do bh.iter() {
-            vec.starts_with(match_vec);
-        }
-    }
-
-    #[bench]
-    fn ends_with_same_vector(bh: &mut BenchHarness) {
-        let vec: ~[uint] = vec::from_fn(100, |i| i);
-        do bh.iter() {
-            vec.ends_with(vec);
-        }
-    }
-
-    #[bench]
-    fn ends_with_single_element(bh: &mut BenchHarness) {
-        let vec: ~[uint] = ~[0u];
-        do bh.iter() {
-            vec.ends_with(vec);
-        }
-    }
-
-    #[bench]
-    fn ends_with_diff_one_element_at_beginning(bh: &mut BenchHarness) {
-        let vec: ~[uint] = vec::from_fn(100, |i| i);
-        let mut match_vec: ~[uint] = vec::from_fn(100, |i| i);
-        match_vec[0] = 200;
-        do bh.iter() {
-            vec.starts_with(match_vec);
-        }
-    }
-
-    #[bench]
-    fn contains_last_element(bh: &mut BenchHarness) {
-        let vec: ~[uint] = vec::from_fn(100, |i| i);
-        do bh.iter() {
-                vec.contains(&99u);
-        }
-    }
 }