auto merge of #18978 : jakub-/rust/roll-up, r=cmr

Author: bors

src/doc/guide-pointers.md

@@ -133,11 +133,11 @@ pass-by-reference. Basically, languages can make two choices (this is made
 up syntax, it's not Rust):
 
 ```{notrust,ignore}
-fn foo(x) {
+func foo(x) {
     x = 5
 }
 
-fn main() {
+func main() {
     i = 1
     foo(i)
     // what is the value of i here?
@@ -153,11 +153,11 @@ So what do pointers have to do with this? Well, since pointers point to a
 location in memory...
 
 ```{notrust,ignore}
-fn foo(&int x) {
+func foo(&int x) {
     *x = 5
 }
 
-fn main() {
+func main() {
     i = 1
     foo(&i)
     // what is the value of i here?
@@ -192,13 +192,13 @@ When you combine pointers and functions, it's easy to accidentally invalidate
 the memory the pointer is pointing to. For example:
 
 ```{notrust,ignore}
-fn make_pointer(): &int {
+func make_pointer(): &int {
     x = 5;
 
     return &x;
 }
 
-fn main() {
+func main() {
     &int i = make_pointer();
     *i = 5; // uh oh!
 }
@@ -214,11 +214,11 @@ issue. Two pointers are said to alias when they point at the same location
 in memory. Like this:
 
 ```{notrust,ignore}
-fn mutate(&int i, int j) {
+func mutate(&int i, int j) {
     *i = j;
 }
 
-fn main() {
+func main() {
   x = 5;
   y = &x;
   z = &x; //y and z are aliased

src/etc/snapshot.py

@@ -75,7 +75,11 @@ def full_snapshot_name(date, rev, platform, hsh):
 
 
 def get_kernel(triple):
-    os_name = triple.split('-')[2]
+    t = triple.split('-')
+    if len(t) == 2:
+      os_name = t[1]
+    else:
+      os_name = t[2]
     if os_name == "windows":
         return "winnt"
     if os_name == "darwin":

src/liballoc/rc.rs

@@ -179,9 +179,9 @@ pub struct Rc<T> {
     _noshare: marker::NoSync
 }
 
-#[stable]
 impl<T> Rc<T> {
     /// Constructs a new reference-counted pointer.
+    #[stable]
     pub fn new(value: T) -> Rc<T> {
         unsafe {
             Rc {
@@ -200,9 +200,7 @@ impl<T> Rc<T> {
             }
         }
     }
-}
 
-impl<T> Rc<T> {
     /// Downgrades the reference-counted pointer to a weak reference.
     #[experimental = "Weak pointers may not belong in this module"]
     pub fn downgrade(&self) -> Weak<T> {

src/libcollections/tree/set.rs

@@ -504,9 +504,9 @@ impl<T: Ord> TreeSet<T> {
     /// # Example
     ///
     /// ```
-    /// use std::collections::BTreeSet;
+    /// use std::collections::TreeSet;
     ///
-    /// let mut set = BTreeSet::new();
+    /// let mut set = TreeSet::new();
     ///
     /// assert_eq!(set.insert(2i), true);
     /// assert_eq!(set.insert(2i), false);
@@ -522,9 +522,9 @@ impl<T: Ord> TreeSet<T> {
     /// # Example
     ///
     /// ```
-    /// use std::collections::BTreeSet;
+    /// use std::collections::TreeSet;
     ///
-    /// let mut set = BTreeSet::new();
+    /// let mut set = TreeSet::new();
     ///
     /// set.insert(2i);
     /// assert_eq!(set.remove(&2), true);

src/libcollections/vec.rs

@@ -645,7 +645,6 @@ impl<T> Vec<T> {
     /// assert!(vec.capacity() >= 3);
     /// ```
     #[stable]
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn shrink_to_fit(&mut self) {
         if mem::size_of::<T>() == 0 { return }
 

src/libcore/any.rs

@@ -88,6 +88,7 @@ use intrinsics::TypeId;
 #[stable]
 pub trait Any: 'static {
     /// Get the `TypeId` of `self`
+    #[stable]
     fn get_type_id(&self) -> TypeId;
 }
 
@@ -117,7 +118,6 @@ pub trait AnyRefExt<'a> {
 #[stable]
 impl<'a> AnyRefExt<'a> for &'a Any {
     #[inline]
-    #[stable]
     fn is<T: 'static>(self) -> bool {
         // Get TypeId of the type this function is instantiated with
         let t = TypeId::of::<T>();
@@ -130,7 +130,6 @@ impl<'a> AnyRefExt<'a> for &'a Any {
     }
 
     #[inline]
-    #[unstable = "naming conventions around acquiring references may change"]
     fn downcast_ref<T: 'static>(self) -> Option<&'a T> {
         if self.is::<T>() {
             unsafe {
@@ -159,7 +158,6 @@ pub trait AnyMutRefExt<'a> {
 #[stable]
 impl<'a> AnyMutRefExt<'a> for &'a mut Any {
     #[inline]
-    #[unstable = "naming conventions around acquiring references may change"]
     fn downcast_mut<T: 'static>(self) -> Option<&'a mut T> {
         if self.is::<T>() {
             unsafe {