---

yaml
---
r: 272199
b: refs/heads/auto
c: 28e45bb
h: refs/heads/master
i:
  272197: eeb8450
  272195: 8465503
  272191: 4b60fd2

Author: tbu-

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: cf0a01a161ebbf01230f2e12b7ec8ce9544d4d5f
+refs/heads/auto: 28e45bb96a2d6e956cc2e8cd1a8686a3de97eb25
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/README.md

@@ -177,11 +177,10 @@ To contribute to Rust, please see [CONTRIBUTING](CONTRIBUTING.md).
 Rust has an [IRC] culture and most real-time collaboration happens in a
 variety of channels on Mozilla's IRC network, irc.mozilla.org. The
 most popular channel is [#rust], a venue for general discussion about
-Rust. And a good place to ask for help would be [#rust-beginners].
+Rust, and a good place to ask for help.
 
 [IRC]: https://en.wikipedia.org/wiki/Internet_Relay_Chat
 [#rust]: irc://irc.mozilla.org/rust
-[#rust-beginners]: irc://irc.mozilla.org/rust-beginners
 
 ## License
 

branches/auto/src/doc/book/getting-started.md

@@ -164,15 +164,13 @@ installed. Doing so will depend on your specific system, consult its
 documentation for more details.
 
 If not, there are a number of places where we can get help. The easiest is
-[the #rust-beginners IRC channel on irc.mozilla.org][irc-beginners] and for
-general discussion [the #rust IRC channel on irc.mozilla.org][irc], which we
-can access through [Mibbit][mibbit]. Then we'll be chatting with other
-Rustaceans (a silly nickname we call ourselves) who can help us out. Other great
-resources include [the user’s forum][users] and [Stack Overflow][stackoverflow].
+[the #rust IRC channel on irc.mozilla.org][irc], which we can access through
+[Mibbit][mibbit]. Click that link, and we'll be chatting with other Rustaceans
+(a silly nickname we call ourselves) who can help us out. Other great resources
+include [the user’s forum][users], and [Stack Overflow][stackoverflow].
 
-[irc-beginners]: irc://irc.mozilla.org/#rust-beginners
 [irc]: irc://irc.mozilla.org/#rust
-[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners,%23rust
+[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
 [users]: https://users.rust-lang.org/
 [stackoverflow]: http://stackoverflow.com/questions/tagged/rust
 

branches/auto/src/doc/nomicon/vec.md

@@ -2,7 +2,7 @@
 
 To bring everything together, we're going to write `std::Vec` from scratch.
 Because all the best tools for writing unsafe code are unstable, this
-project will only work on nightly (as of Rust 1.9.0). With the exception of the
+project will only work on nightly (as of Rust 1.2.0). With the exception of the
 allocator API, much of the unstable code we'll use is expected to be stabilized
 in a similar form as it is today.
 

branches/auto/src/libcollections/lib.rs

@@ -48,7 +48,6 @@
 #![feature(placement_new_protocol)]
 #![feature(shared)]
 #![feature(slice_patterns)]
-#![feature(specialization)]
 #![feature(staged_api)]
 #![feature(step_by)]
 #![feature(str_char)]

branches/auto/src/libcollections/string.rs

@@ -1755,7 +1755,7 @@ pub trait ToString {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: fmt::Display + ?Sized> ToString for T {
     #[inline]
-    default fn to_string(&self) -> String {
+    fn to_string(&self) -> String {
         use core::fmt::Write;
         let mut buf = String::new();
         let _ = buf.write_fmt(format_args!("{}", self));
@@ -1764,14 +1764,6 @@ impl<T: fmt::Display + ?Sized> ToString for T {
     }
 }
 
-#[stable(feature = "str_to_string_specialization", since = "1.9.0")]
-impl ToString for str {
-    #[inline]
-    fn to_string(&self) -> String {
-        String::from(self)
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl AsRef<str> for String {
     #[inline]

branches/auto/src/libcore/cell.rs

@@ -147,8 +147,8 @@
 use clone::Clone;
 use cmp::{PartialEq, Eq};
 use default::Default;
-use marker::{Copy, Send, Sync, Sized, Unsize};
-use ops::{Deref, DerefMut, Drop, FnOnce, CoerceUnsized};
+use marker::{Copy, Send, Sync, Sized};
+use ops::{Deref, DerefMut, Drop, FnOnce};
 use option::Option;
 use option::Option::{None, Some};
 
@@ -216,6 +216,10 @@ impl<T:Copy> Cell<T> {
 
     /// Returns a reference to the underlying `UnsafeCell`.
     ///
+    /// # Safety
+    ///
+    /// This function is `unsafe` because `UnsafeCell`'s field is public.
+    ///
     /// # Examples
     ///
     /// ```
@@ -225,11 +229,11 @@ impl<T:Copy> Cell<T> {
     ///
     /// let c = Cell::new(5);
     ///
-    /// let uc = c.as_unsafe_cell();
+    /// let uc = unsafe { c.as_unsafe_cell() };
     /// ```
     #[inline]
     #[unstable(feature = "as_unsafe_cell", issue = "27708")]
-    pub fn as_unsafe_cell(&self) -> &UnsafeCell<T> {
+    pub unsafe fn as_unsafe_cell(&self) -> &UnsafeCell<T> {
         &self.value
     }
 }
@@ -634,9 +638,6 @@ impl<'b, T: ?Sized> Ref<'b, T> {
     }
 }
 
-#[unstable(feature = "coerce_unsized", issue = "27732")]
-impl<'b, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Ref<'b, U>> for Ref<'b, T> {}
-
 impl<'b, T: ?Sized> RefMut<'b, T> {
     /// Make a new `RefMut` for a component of the borrowed data, e.g. an enum
     /// variant.
@@ -769,9 +770,6 @@ impl<'b, T: ?Sized> DerefMut for RefMut<'b, T> {
     }
 }
 
-#[unstable(feature = "coerce_unsized", issue = "27732")]
-impl<'b, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<RefMut<'b, U>> for RefMut<'b, T> {}
-
 /// The core primitive for interior mutability in Rust.
 ///
 /// `UnsafeCell<T>` is a type that wraps some `T` and indicates unsafe interior operations on the

branches/auto/src/libcore/sync/atomic.rs

@@ -695,7 +695,7 @@ impl AtomicIsize {
         unsafe { atomic_compare_exchange(self.v.get(), current, new, success, failure) }
     }
 
-    /// Stores a value into the `isize` if the current value is the same as the `current` value.
+    /// Stores a value into the `isize if the current value is the same as the `current` value.
     ///
     /// Unlike `compare_exchange`, this function is allowed to spuriously fail even when the
     /// comparison succeeds, which can result in more efficient code on some platforms. The

branches/auto/src/libcoretest/cell.rs

@@ -261,23 +261,3 @@ fn refcell_unsized() {
     let comp: &mut [i32] = &mut [4, 2, 5];
     assert_eq!(&*cell.borrow(), comp);
 }
-
-#[test]
-fn refcell_ref_coercion() {
-    let cell: RefCell<[i32; 3]> = RefCell::new([1, 2, 3]);
-    {
-        let mut cellref: RefMut<[i32; 3]> = cell.borrow_mut();
-        cellref[0] = 4;
-        let mut coerced: RefMut<[i32]> = cellref;
-        coerced[2] = 5;
-    }
-    {
-        let comp: &mut [i32] = &mut [4, 2, 5];
-        let cellref: Ref<[i32; 3]> = cell.borrow();
-        assert_eq!(&*cellref, comp);
-        let coerced: Ref<[i32]> = cellref;
-        assert_eq!(&*coerced, comp);
-    }
-}
-
-

branches/auto/src/librustc/diagnostics.rs

@@ -1033,47 +1033,6 @@ fn main() {
     some_func(5i32); // ok!
 }
 ```
-
-Or in a generic context, an erroneous code example would look like:
-```compile_fail
-fn some_func<T>(foo: T) {
-    println!("{:?}", foo); // error: the trait `core::fmt::Debug` is not
-                           //        implemented for the type `T`
-}
-
-fn main() {
-    // We now call the method with the i32 type,
-    // which *does* implement the Debug trait.
-    some_func(5i32);
-}
-```
-
-Note that the error here is in the definition of the generic function: Although
-we only call it with a parameter that does implement `Debug`, the compiler
-still rejects the function: It must work with all possible input types. In
-order to make this example compile, we need to restrict the generic type we're
-accepting:
-```
-use std::fmt;
-
-// Restrict the input type to types that implement Debug.
-fn some_func<T: fmt::Debug>(foo: T) {
-    println!("{:?}", foo);
-}
-
-fn main() {
-    // Calling the method is still fine, as i32 implements Debug.
-    some_func(5i32);
-
-    // This would fail to compile now:
-    // struct WithoutDebug;
-    // some_func(WithoutDebug);
-}
-
-Rust only looks at the signature of the called function, as such it must
-already specify all requirements that will be used for every type parameter.
-```
-
 "##,
 
 E0281: r##"

branches/auto/src/librustc/front/map/mod.rs

@@ -581,6 +581,14 @@ impl<'ast> Map<'ast> {
         }
     }
 
+    pub fn get_foreign_vis(&self, id: NodeId) -> Visibility {
+        let vis = self.expect_foreign_item(id).vis; // read recorded by `expect_foreign_item`
+        match self.find(self.get_parent(id)) { // read recorded by `find`
+            Some(NodeItem(i)) => vis.inherit_from(i.vis),
+            _ => vis
+        }
+    }
+
     pub fn expect_item(&self, id: NodeId) -> &'ast Item {
         match self.find(id) { // read recorded by `find`
             Some(NodeItem(item)) => item,