---

yaml
---
r: 179079
b: refs/heads/master
c: d4f9ec5
h: refs/heads/master
i:
  179077: 62f744f
  179075: 97c3149
  179071: c66d46b
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7324c2cf4f09d44d1bde8c37716de9eca4aac565
+refs/heads/master: d4f9ec566249f88845c88c8b897097a262b4e0af
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ac134f7ca435551964996ee88319241cd3c7c110
 refs/heads/try: ccf8fedf1cffcb8f6f3581d53d220039e192fe77

trunk/src/doc/reference.md

@@ -256,11 +256,11 @@ cases mentioned in [Number literals](#number-literals) below.
 
 | [Number literals](#number-literals)`*` | Example | Exponentiation | Suffixes |
 |----------------------------------------|---------|----------------|----------|
-| Decimal integer | `98_222is` | `N/A` | Integer suffixes |
-| Hex integer | `0xffis` | `N/A` | Integer suffixes |
-| Octal integer | `0o77is` | `N/A` | Integer suffixes |
-| Binary integer | `0b1111_0000is` | `N/A` | Integer suffixes |
-| Floating-point | `123.0E+77f64` | `Optional` | Floating-point suffixes |
+| Decimal integer | `98_222` | `N/A` | Integer suffixes |
+| Hex integer | `0xff` | `N/A` | Integer suffixes |
+| Octal integer | `0o77` | `N/A` | Integer suffixes |
+| Binary integer | `0b1111_0000` | `N/A` | Integer suffixes |
+| Floating-point | `123.0E+77` | `Optional` | Floating-point suffixes |
 
 `*` All number literals allow `_` as a visual separator: `1_234.0E+18f64`
 
@@ -2467,6 +2467,12 @@ The currently implemented features of the reference compiler are:
 
 * `associated_types` - Allows type aliases in traits. Experimental.
 
+* `no_std` - Allows the `#![no_std]` crate attribute, which disables the implicit
+             `extern crate std`. This typically requires use of the unstable APIs
+             behind the libstd "facade", such as libcore and libcollections. It
+             may also cause problems when using syntax extensions, including
+             `#[derive]`.
+
 If a feature is promoted to a language feature, then all existing programs will
 start to receive compilation warnings about #[feature] directives which enabled
 the new feature (because the directive is no longer necessary). However, if a

trunk/src/doc/trpl/unsafe.md

@@ -433,6 +433,7 @@ attribute attached to the crate.
 ```ignore
 // a minimal library
 #![crate_type="lib"]
+#![feature(no_std)]
 #![no_std]
 # // fn main() {} tricked you, rustdoc!
 ```
@@ -446,8 +447,8 @@ The function marked `#[start]` is passed the command line parameters
 in the same format as C:
 
 ```
+#![feature(lang_items, start, no_std)]
 #![no_std]
-#![feature(lang_items, start)]
 
 // Pull in the system libc library for what crt0.o likely requires
 extern crate libc;
@@ -473,6 +474,7 @@ correct ABI and the correct name, which requires overriding the
 compiler's name mangling too:
 
 ```ignore
+#![feature(no_std)]
 #![no_std]
 #![no_main]
 #![feature(lang_items, start)]
@@ -528,8 +530,8 @@ As an example, here is a program that will calculate the dot product of two
 vectors provided from C, using idiomatic Rust practices.
 
 ```
+#![feature(lang_items, start, no_std)]
 #![no_std]
-#![feature(lang_items, start)]
 
 # extern crate libc;
 extern crate core;
@@ -576,10 +578,6 @@ extern fn panic_fmt(args: &core::fmt::Arguments,
 #[lang = "eh_personality"] extern fn eh_personality() {}
 # #[start] fn start(argc: isize, argv: *const *const u8) -> isize { 0 }
 # fn main() {}
-# mod std {  // for-loops
-#     pub use core::iter;
-#     pub use core::option;
-# }
 ```
 
 Note that there is one extra lang item here which differs from the examples
@@ -656,8 +654,8 @@ and one for deallocation. A freestanding program that uses the `Box`
 sugar for dynamic allocations via `malloc` and `free`:
 
 ```
+#![feature(lang_items, box_syntax, start, no_std)]
 #![no_std]
-#![feature(lang_items, box_syntax, start)]
 
 extern crate libc;
 

trunk/src/liballoc/lib.rs

@@ -65,6 +65,7 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/")]
 
+#![feature(no_std)]
 #![no_std]
 #![feature(lang_items, unsafe_destructor)]
 #![feature(box_syntax)]
@@ -126,7 +127,8 @@ pub fn oom() -> ! {
 #[doc(hidden)]
 pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
-#[cfg(not(test))]
+// NOTE: remove after next snapshot
+#[cfg(all(stage0, not(test)))]
 #[doc(hidden)]
 mod std {
     pub use core::fmt;

trunk/src/liballoc/rc.rs

@@ -172,7 +172,7 @@ struct RcBox<T> {
 
 /// An immutable reference-counted pointer type.
 ///
-/// See the [module level documentation](../index.html) for more details.
+/// See the [module level documentation](./index.html) for more details.
 #[unsafe_no_drop_flag]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Rc<T> {
@@ -624,7 +624,7 @@ impl<T: fmt::Debug> fmt::Debug for Rc<T> {
 ///
 /// Weak references do not count when determining if the inner value should be dropped.
 ///
-/// See the [module level documentation](../index.html) for more.
+/// See the [module level documentation](./index.html) for more.
 #[unsafe_no_drop_flag]
 #[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]

trunk/src/libcollections/btree/map.rs

@@ -910,8 +910,6 @@ impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
 impl<K: Ord, Q: ?Sized, V> IndexMut<Q> for BTreeMap<K, V>
     where Q: BorrowFrom<K> + Ord
 {
-    type Output = V;
-
     fn index_mut(&mut self, key: &Q) -> &mut V {
         self.get_mut(key).expect("no entry found for key")
     }

trunk/src/libstd/fmt.rs renamed to trunk/src/libcollections/fmt.rs

@@ -1,4 +1,4 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -134,7 +134,7 @@
 //! * `E` ⇒ `UpperExp`
 //!
 //! What this means is that any type of argument which implements the
-//! `std::fmt::Binary` trait can then be formatted with `{:b}`. Implementations
+//! `fmt::Binary` trait can then be formatted with `{:b}`. Implementations
 //! are provided for these traits for a number of primitive types by the
 //! standard library as well. If no format is specified (as in `{}` or `{:6}`),
 //! then the format trait used is the `Display` trait.
@@ -146,7 +146,7 @@
 //! # use std::fmt;
 //! # struct Foo; // our custom type
 //! # impl fmt::Display for Foo {
-//! fn fmt(&self, f: &mut std::fmt::Formatter) -> fmt::Result {
+//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 //! # write!(f, "testing, testing")
 //! # } }
 //! ```
@@ -403,8 +403,6 @@
 
 #![unstable(feature = "std_misc")]
 
-use string;
-
 pub use core::fmt::{Formatter, Result, Writer, rt};
 pub use core::fmt::{Show, String, Octal, Binary};
 pub use core::fmt::{Display, Debug};
@@ -413,6 +411,8 @@ pub use core::fmt::{LowerExp, UpperExp};
 pub use core::fmt::Error;
 pub use core::fmt::{ArgumentV1, Arguments, write, radix, Radix, RadixFmt};
 
+use string;
+
 /// The format function takes a precompiled format string and a list of
 /// arguments, to return the resulting formatted string.
 ///
@@ -434,3 +434,15 @@ pub fn format(args: Arguments) -> string::String {
     let _ = write!(&mut output, "{}", args);
     output
 }
+
+#[cfg(test)]
+mod tests {
+    use prelude::*;
+    use fmt;
+
+    #[test]
+    fn test_format() {
+        let s = fmt::format(format_args!("Hello, {}!", "world"));
+        assert_eq!(s.as_slice(), "Hello, world!");
+    }
+}

trunk/src/libcollections/lib.rs

@@ -33,6 +33,7 @@
 #![cfg_attr(test, feature(test))]
 #![cfg_attr(test, allow(deprecated))] // rand
 
+#![feature(no_std)]
 #![no_std]
 
 #[macro_use]
@@ -68,6 +69,7 @@ mod bit;
 mod btree;
 pub mod dlist;
 pub mod enum_set;
+pub mod fmt;
 pub mod ring_buf;
 pub mod slice;
 pub mod str;
@@ -107,15 +109,16 @@ pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
 #[cfg(not(test))]
 mod std {
-    pub use core::fmt;      // necessary for panic!()
-    pub use core::option;   // necessary for panic!()
-    pub use core::clone;    // derive(Clone)
-    pub use core::cmp;      // derive(Eq, Ord, etc.)
-    pub use core::marker;   // derive(Copy)
-    pub use core::hash;     // derive(Hash)
+    // NOTE: remove after next snapshot
+    #[cfg(stage0)] pub use core::clone;    // derive(Clone)
+    #[cfg(stage0)] pub use core::cmp;      // derive(Eq, Ord, etc.)
+    #[cfg(stage0)] pub use core::marker;   // derive(Copy)
+    #[cfg(stage0)] pub use core::hash;     // derive(Hash)
+    #[cfg(stage0)] pub use core::iter;
+    #[cfg(stage0)] pub use core::fmt;      // necessary for panic!()
+    #[cfg(stage0)] pub use core::option;   // necessary for panic!()
+
     pub use core::ops;      // RangeFull
-    // for-loops
-    pub use core::iter;
 }
 
 #[cfg(test)]

trunk/src/libcollections/macros.rs

@@ -22,3 +22,19 @@ macro_rules! vec {
     );
     ($($x:expr,)*) => (vec![$($x),*])
 }
+
+/// Use the syntax described in `std::fmt` to create a value of type `String`.
+/// See `std::fmt` for more information.
+///
+/// # Example
+///
+/// ```
+/// format!("test");
+/// format!("hello {}", "world!");
+/// format!("x = {}, y = {y}", 10, y = 30);
+/// ```
+#[macro_export]
+#[stable(feature = "rust1", since = "1.0.0")]
+macro_rules! format {
+    ($($arg:tt)*) => ($crate::fmt::format(format_args!($($arg)*)))
+}

trunk/src/libcollections/ring_buf.rs

@@ -27,8 +27,8 @@ use core::ops::{Index, IndexMut};
 use core::ptr;
 use core::raw::Slice as RawSlice;
 
-use std::hash::{Writer, Hash, Hasher};
-use std::cmp;
+use core::hash::{Writer, Hash, Hasher};
+use core::cmp;
 
 use alloc::heap;
 
@@ -1591,8 +1591,6 @@ impl<A> Index<usize> for RingBuf<A> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A> IndexMut<usize> for RingBuf<A> {
-    type Output = A;
-
     #[inline]
     fn index_mut(&mut self, i: &usize) -> &mut A {
         self.get_mut(*i).expect("Out of bounds access")

trunk/src/libcollections/vec.rs

@@ -1286,8 +1286,6 @@ impl<T> Index<usize> for Vec<T> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> IndexMut<usize> for Vec<T> {
-    type Output = T;
-
     #[inline]
     fn index_mut(&mut self, index: &usize) -> &mut T {
         // NB built-in indexing via `&mut [T]`
@@ -1331,31 +1329,27 @@ impl<T> ops::Index<ops::RangeFull> for Vec<T> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
-    type Output = [T];
     #[inline]
     fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
         IndexMut::index_mut(&mut **self, index)
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
-    type Output = [T];
     #[inline]
     fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
         IndexMut::index_mut(&mut **self, index)
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
-    type Output = [T];
     #[inline]
     fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
         IndexMut::index_mut(&mut **self, index)
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
-    type Output = [T];
     #[inline]
     fn index_mut(&mut self, _index: &ops::RangeFull) -> &mut [T] {
         self.as_mut_slice()

trunk/src/libcollections/vec_map.rs

@@ -712,8 +712,6 @@ impl<V> Index<usize> for VecMap<V> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<V> IndexMut<usize> for VecMap<V> {
-    type Output = V;
-
     #[inline]
     fn index_mut<'a>(&'a mut self, i: &usize) -> &'a mut V {
         self.get_mut(i).expect("key not present")

trunk/src/libcore/iter.rs

@@ -67,7 +67,7 @@ use num::{ToPrimitive, Int};
 use ops::{Add, Deref, FnMut};
 use option::Option;
 use option::Option::{Some, None};
-use std::marker::Sized;
+use marker::Sized;
 use usize;
 
 /// An interface for dealing with "external iterators". These types of iterators

trunk/src/libcore/lib.rs

@@ -56,6 +56,7 @@
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 
+#![feature(no_std)]
 #![no_std]
 #![allow(raw_pointer_derive)]
 #![deny(missing_docs)]
@@ -148,17 +149,25 @@ mod array;
 mod core {
     pub use panicking;
     pub use fmt;
+    #[cfg(not(stage0))] pub use clone;
+    #[cfg(not(stage0))] pub use cmp;
+    #[cfg(not(stage0))] pub use hash;
+    #[cfg(not(stage0))] pub use marker;
+    #[cfg(not(stage0))] pub use option;
+    #[cfg(not(stage0))] pub use iter;
 }
 
 #[doc(hidden)]
 mod std {
-    pub use clone;
-    pub use cmp;
-    pub use fmt;
-    pub use hash;
-    pub use marker;
+    // NOTE: remove after next snapshot
+    #[cfg(stage0)] pub use clone;
+    #[cfg(stage0)] pub use cmp;
+    #[cfg(stage0)] pub use hash;
+    #[cfg(stage0)] pub use marker;
+    #[cfg(stage0)] pub use option;
+    #[cfg(stage0)] pub use fmt;
+    #[cfg(stage0)] pub use iter;
+
+    // range syntax
     pub use ops;
-    pub use option;
-    // for-loops
-    pub use iter;
 }