---

yaml
---
r: 235645
b: refs/heads/stable
c: 4128583
h: refs/heads/master
i:
  235643: 27b9615
v: v3

Author: pnkfelix

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: d33cab1b1fa4943a4bf37baa8c7421e672df10c7
+refs/heads/stable: 4128583939a71d48d0e9ec948516e039ead8117d
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/liballoc/lib.rs

@@ -135,3 +135,20 @@ pub fn oom() -> ! {
     //                allocate.
     unsafe { core::intrinsics::abort() }
 }
+
+// FIXME(#14344): When linking liballoc with libstd, this library will be linked
+//                as an rlib (it only exists as an rlib). It turns out that an
+//                optimized standard library doesn't actually use *any* symbols
+//                from this library. Everything is inlined and optimized away.
+//                This means that linkers will actually omit the object for this
+//                file, even though it may be needed in the future.
+//
+//                To get around this for now, we define a dummy symbol which
+//                will never get inlined so the stdlib can call it. The stdlib's
+//                reference to this symbol will cause this library's object file
+//                to get linked in to libstd successfully (the linker won't
+//                optimize it out).
+#[doc(hidden)]
+#[unstable(feature = "issue_14344_fixme")]
+#[cfg(stage0)]
+pub fn fixme_14344_be_sure_to_link_to_collections() {}

branches/stable/src/libcollections/lib.rs

@@ -133,6 +133,13 @@ pub mod btree_set {
     pub use btree::set::*;
 }
 
+
+// FIXME(#14344) this shouldn't be necessary
+#[doc(hidden)]
+#[unstable(feature = "issue_14344_fixme")]
+#[cfg(stage0)]
+pub fn fixme_14344_be_sure_to_link_to_collections() {}
+
 #[cfg(not(test))]
 mod std {
     pub use core::ops;      // RangeFull

branches/stable/src/libcollections/slice.rs

@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! A dynamically-sized view into a contiguous sequence, `[T]`.
+//! Utilities for slice manipulation
 //!
+//! The `slice` module contains useful code to help work with slice values.
 //! Slices are a view into a block of memory represented as a pointer and a
 //! length.
 //!
@@ -77,8 +78,7 @@
 //!   iterators.
 //! * Further methods that return iterators are `.split()`, `.splitn()`,
 //!   `.chunks()`, `.windows()` and more.
-//!
-//! *[See also the slice primitive type](../primitive.slice.html).*
+#![doc(primitive = "slice")]
 #![stable(feature = "rust1", since = "1.0.0")]
 
 // Many of the usings in this module are only used in the test configuration.

branches/stable/src/libcollections/str.rs

@@ -8,11 +8,43 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Unicode string slices
+//! Unicode string manipulation (the `str` type).
 //!
-//! *[See also the `str` primitive type](../primitive.str.html).*
-
+//! Rust's `str` type is one of the core primitive types of the language. `&str`
+//! is the borrowed string type. This type of string can only be created from
+//! other strings, unless it is a `&'static str` (see below). It is not possible
+//! to move out of borrowed strings because they are owned elsewhere.
+//!
+//! # Examples
+//!
+//! Here's some code that uses a `&str`:
+//!
+//! ```
+//! let s = "Hello, world.";
+//! ```
+//!
+//! This `&str` is a `&'static str`, which is the type of string literals.
+//! They're `'static` because literals are available for the entire lifetime of
+//! the program.
+//!
+//! You can get a non-`'static` `&str` by taking a slice of a `String`:
+//!
+//! ```
+//! let some_string = "Hello, world.".to_string();
+//! let s = &some_string;
+//! ```
+//!
+//! # Representation
+//!
+//! Rust's string type, `str`, is a sequence of Unicode scalar values encoded as
+//! a stream of UTF-8 bytes. All [strings](../../reference.html#literals) are
+//! guaranteed to be validly encoded UTF-8 sequences. Additionally, strings are
+//! not null-terminated and can thus contain null bytes.
+//!
+//! The actual representation of `str`s have direct mappings to slices: `&str`
+//! is the same as `&[u8]`.
 
+#![doc(primitive = "str")]
 #![stable(feature = "rust1", since = "1.0.0")]
 
 // Many of the usings in this module are only used in the test configuration.

branches/stable/src/libcollections/string.rs

@@ -979,20 +979,23 @@ impl ops::Index<ops::RangeFull> for String {
     }
 }
 
+#[cfg(not(stage0))]
 #[stable(feature = "derefmut_for_string", since = "1.2.0")]
 impl ops::IndexMut<ops::Range<usize>> for String {
     #[inline]
     fn index_mut(&mut self, index: ops::Range<usize>) -> &mut str {
         &mut self[..][index]
     }
 }
+#[cfg(not(stage0))]
 #[stable(feature = "derefmut_for_string", since = "1.2.0")]
 impl ops::IndexMut<ops::RangeTo<usize>> for String {
     #[inline]
     fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {
         &mut self[..][index]
     }
 }
+#[cfg(not(stage0))]
 #[stable(feature = "derefmut_for_string", since = "1.2.0")]
 impl ops::IndexMut<ops::RangeFrom<usize>> for String {
     #[inline]

branches/stable/src/libcore/array.rs

@@ -11,9 +11,8 @@
 //! Implementations of things like `Eq` for fixed-length arrays
 //! up to a certain length. Eventually we should able to generalize
 //! to all lengths.
-//!
-//! *[See also the array primitive type](../primitive.array.html).*
 
+#![doc(primitive = "array")]
 #![unstable(feature = "fixed_size_array",
             reason = "traits and impls are better expressed through generic \
                       integer constants")]

branches/stable/src/libcore/char.rs

@@ -13,6 +13,7 @@
 //! For more details, see ::rustc_unicode::char (a.k.a. std::char)
 
 #![allow(non_snake_case)]
+#![doc(primitive = "char")]
 #![stable(feature = "core_char", since = "1.2.0")]
 
 use iter::Iterator;

branches/stable/src/libcore/lib.rs

@@ -154,6 +154,10 @@ pub mod str;
 pub mod hash;
 pub mod fmt;
 
+#[doc(primitive = "bool")]
+mod bool {
+}
+
 // note: does not need to be public
 mod tuple;
 

branches/stable/src/libcore/num/f32.rs

@@ -10,6 +10,7 @@
 
 //! Operations and constants for 32-bits floats (`f32` type)
 
+#![doc(primitive = "f32")]
 // FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353
 #![allow(overflowing_literals)]
 

branches/stable/src/libcore/num/f64.rs

@@ -10,6 +10,7 @@
 
 //! Operations and constants for 64-bits floats (`f64` type)
 
+#![doc(primitive = "f64")]
 // FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353
 #![allow(overflowing_literals)]
 

branches/stable/src/libcore/num/i16.rs

@@ -11,5 +11,6 @@
 //! Operations and constants for signed 16-bits integers (`i16` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "i16")]
 
 int_module! { i16, 16 }

branches/stable/src/libcore/num/i32.rs

@@ -11,5 +11,6 @@
 //! Operations and constants for signed 32-bits integers (`i32` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "i32")]
 
 int_module! { i32, 32 }

branches/stable/src/libcore/num/i64.rs

@@ -11,5 +11,6 @@
 //! Operations and constants for signed 64-bits integers (`i64` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "i64")]
 
 int_module! { i64, 64 }

branches/stable/src/libcore/num/i8.rs

@@ -11,5 +11,6 @@
 //! Operations and constants for signed 8-bits integers (`i8` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "i8")]
 
 int_module! { i8, 8 }

branches/stable/src/libcore/num/isize.rs

@@ -11,6 +11,7 @@
 //! Operations and constants for pointer-sized signed integers (`isize` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "isize")]
 
 #[cfg(target_pointer_width = "32")]
 int_module! { isize, 32 }

branches/stable/src/libcore/num/u16.rs

@@ -11,5 +11,6 @@
 //! Operations and constants for unsigned 16-bits integers (`u16` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "u16")]
 
 uint_module! { u16, i16, 16 }

branches/stable/src/libcore/num/u32.rs

@@ -11,5 +11,6 @@
 //! Operations and constants for unsigned 32-bits integers (`u32` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "u32")]
 
 uint_module! { u32, i32, 32 }

branches/stable/src/libcore/num/u64.rs

@@ -11,5 +11,6 @@
 //! Operations and constants for unsigned 64-bits integer (`u64` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "u64")]
 
 uint_module! { u64, i64, 64 }

branches/stable/src/libcore/num/u8.rs

@@ -11,5 +11,6 @@
 //! Operations and constants for unsigned 8-bits integers (`u8` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "u8")]
 
 uint_module! { u8, i8, 8 }

branches/stable/src/libcore/num/usize.rs

@@ -11,5 +11,6 @@
 //! Operations and constants for pointer-sized unsigned integers (`usize` type)
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "usize")]
 
 uint_module! { usize, isize, ::isize::BITS }

branches/stable/src/libcore/ptr.rs

@@ -10,11 +10,84 @@
 
 // FIXME: talk about offset, copy_memory, copy_nonoverlapping_memory
 
-//! Raw, unsafe pointers, `*const T`, and `*mut T`
+//! Operations on raw pointers, `*const T`, and `*mut T`.
 //!
-//! *[See also the pointer primitive types](../primitive.pointer.html).*
+//! Working with raw pointers in Rust is uncommon,
+//! typically limited to a few patterns.
+//!
+//! Use the `null` function to create null pointers, and the `is_null` method
+//! of the `*const T` type  to check for null. The `*const T` type also defines
+//! the `offset` method, for pointer math.
+//!
+//! # Common ways to create raw pointers
+//!
+//! ## 1. Coerce a reference (`&T`) or mutable reference (`&mut T`).
+//!
+//! ```
+//! let my_num: i32 = 10;
+//! let my_num_ptr: *const i32 = &my_num;
+//! let mut my_speed: i32 = 88;
+//! let my_speed_ptr: *mut i32 = &mut my_speed;
+//! ```
+//!
+//! To get a pointer to a boxed value, dereference the box:
+//!
+//! ```
+//! let my_num: Box<i32> = Box::new(10);
+//! let my_num_ptr: *const i32 = &*my_num;
+//! let mut my_speed: Box<i32> = Box::new(88);
+//! let my_speed_ptr: *mut i32 = &mut *my_speed;
+//! ```
+//!
+//! This does not take ownership of the original allocation
+//! and requires no resource management later,
+//! but you must not use the pointer after its lifetime.
+//!
+//! ## 2. Consume a box (`Box<T>`).
+//!
+//! The `into_raw` function consumes a box and returns
+//! the raw pointer. It doesn't destroy `T` or deallocate any memory.
+//!
+//! ```
+//! # #![feature(box_raw)]
+//! let my_speed: Box<i32> = Box::new(88);
+//! let my_speed: *mut i32 = Box::into_raw(my_speed);
+//!
+//! // By taking ownership of the original `Box<T>` though
+//! // we are obligated to put it together later to be destroyed.
+//! unsafe {
+//!     drop(Box::from_raw(my_speed));
+//! }
+//! ```
+//!
+//! Note that here the call to `drop` is for clarity - it indicates
+//! that we are done with the given value and it should be destroyed.
+//!
+//! ## 3. Get it from C.
+//!
+//! ```
+//! # #![feature(libc)]
+//! extern crate libc;
+//!
+//! use std::mem;
+//!
+//! fn main() {
+//!     unsafe {
+//!         let my_num: *mut i32 = libc::malloc(mem::size_of::<i32>() as libc::size_t) as *mut i32;
+//!         if my_num.is_null() {
+//!             panic!("failed to allocate memory");
+//!         }
+//!         libc::free(my_num as *mut libc::c_void);
+//!     }
+//! }
+//! ```
+//!
+//! Usually you wouldn't literally use `malloc` and `free` from Rust,
+//! but C APIs hand out a lot of pointers generally, so are a common source
+//! of raw pointers in Rust.
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "pointer")]
 
 use mem;
 use clone::Clone;

branches/stable/src/libcore/slice.rs

@@ -13,6 +13,7 @@
 //! For more details `std::slice`.
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "slice")]
 
 // How this module is organized.
 //

branches/stable/src/libcore/str/mod.rs

@@ -12,6 +12,7 @@
 //!
 //! For more details, see std::str
 
+#![doc(primitive = "str")]
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use self::pattern::Pattern;

branches/stable/src/libcore/tuple.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! A finite heterogeneous sequence, `(T, U, ..)`
+//! Operations on tuples
 //!
 //! To access a single element of a tuple one can use the `.0`
 //! field access syntax.
@@ -28,6 +28,7 @@
 //! * `Default`
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![doc(primitive = "tuple")]
 
 use clone::Clone;
 use cmp::*;

branches/stable/src/liblibc/lib.rs

@@ -6535,4 +6535,8 @@ pub mod funcs {
     }
 }
 
+#[doc(hidden)]
+#[cfg(stage0)]
+pub fn issue_14344_workaround() {} // FIXME #14344 force linkage to happen correctly
+
 #[test] fn work_on_windows() { } // FIXME #10872 needed for a happy windows