---

yaml
---
r: 93813
b: refs/heads/try
c: 09ed791
h: refs/heads/master
i:
  93811: cbab89d
v: v3

Author: bors

[refs]

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

branches/try/doc/tutorial.md

@@ -1320,7 +1320,8 @@ 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]);
 
-let mut a = Rc::new([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]); // the variable is mutable, but not the box
+// 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]);
 a = z;
 ~~~
 

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

@@ -141,11 +141,9 @@ impl Visitor<()> for Context {
             },
             ast::ty_box(_) => {
                 self.gate_feature("managed_boxes", t.span,
-                                  "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.");
+                                  "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.");
             }
             _ => {}
         }

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, local_def};
+use syntax::ast_util::{def_id_of_def, is_local};
 use syntax::attr;
 use syntax::parse::token;
 use syntax::visit::Visitor;
@@ -310,47 +310,13 @@ 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
+                    // worklist, as determined by the privacy pass
                     ast::item_static(*) | ast::item_ty(*) |
-                        ast::item_mod(*) | ast::item_foreign_mod(*) => {}
+                    ast::item_mod(*) | ast::item_foreign_mod(*) |
+                    ast::item_impl(*) | ast::item_trait(*) |
+                    ast::item_struct(*) | ast::item_enum(*) => {}
 
                     _ => {
                         self.tcx.sess.span_bug(item.span,

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

@@ -2759,6 +2759,7 @@ 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,6 +228,11 @@ 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,7 +3968,8 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
 
     } else {
         match name {
-            "abort"  => (0, ~[], ty::mk_bot()),
+            "abort" => (0, ~[], ty::mk_bot()),
+            "breakpoint" => (0, ~[], ty::mk_nil()),
             "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

@@ -176,6 +176,10 @@ 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(b: &mut BenchHarness) {
+    fn add(bh: &mut BenchHarness) {
         let xs: &[int] = [5, ..10];
         let ys: &[int] = [5, ..10];
-        do b.iter() {
+        do bh.iter() {
             xs + ys;
         }
     }
@@ -3885,4 +3885,72 @@ 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);
+        }
+    }
 }

branches/try/src/libstd/vec.rs

@@ -0,0 +1,15 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub use bar = foo;
+
+mod foo {
+    pub fn frob() {}
+}

branches/try/src/test/auxiliary/privacy_reexport.rs

@@ -57,6 +57,11 @@ pub trait C { //~ ERROR: missing documentation
 #[allow(missing_doc)] pub trait D {}
 
 impl Foo {
+    pub fn foo() {}
+    fn bar() {}
+}
+
+impl PubFoo {
     pub fn foo() {} //~ ERROR: missing documentation
     /// dox
     pub fn foo1() {}

branches/try/src/test/compile-fail/lint-missing-doc.rs

@@ -10,11 +10,20 @@
 
 #[allow(unused_unsafe)];
 #[deny(unsafe_block)];
+#[feature(macro_rules)];
 
 unsafe fn allowed() {}
 
 #[allow(unsafe_block)] fn also_allowed() { unsafe {} }
 
+macro_rules! unsafe_in_macro {
+    () => {
+        unsafe {} //~ ERROR: usage of an `unsafe` block
+    }
+}
+
 fn main() {
     unsafe {} //~ ERROR: usage of an `unsafe` block
+
+    unsafe_in_macro!()
 }

branches/try/src/test/compile-fail/lint-unsafe-block.rs

@@ -31,6 +31,12 @@ mod bar {
         fn bar2(&self) {}
     }
 
+    trait B {
+        fn foo() -> Self;
+    }
+
+    impl B for int { fn foo() -> int { 3 } }
+
     pub enum Enum {
         priv Priv,
         Pub
@@ -108,6 +114,10 @@ mod foo {
         ::bar::baz::A.bar2();   //~ ERROR: struct `A` is inaccessible
                                 //~^ ERROR: method `bar2` is private
                                 //~^^ NOTE: module `baz` is private
+
+        let _: int =
+        ::bar::B::foo();        //~ ERROR: method `foo` is inaccessible
+                                //~^ NOTE: trait `B` is private
         ::lol();
 
         ::bar::Priv; //~ ERROR: variant `Priv` is private

branches/try/src/test/compile-fail/privacy1.rs

@@ -0,0 +1,18 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+// aux-build:privacy_reexport.rs
+
+extern mod privacy_reexport;
+
+fn main() {
+    privacy_reexport::bar::frob();
+}