---

yaml
---
r: 186365
b: refs/heads/try
c: 684e43e
h: refs/heads/master
i:
  186363: 18bce19
v: v3

Author: caspark

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b4c965ee803a4521d8b4575f634e036f93e408f3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 3a96d6a9818fe2affc98a187fb1065120458cee9
-refs/heads/try: 74b8740719c1b427f79b67d6bc51e9d448dd9c49
+refs/heads/try: 684e43e712d1e58799cd81f55e56ff4361108564
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/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_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 |
+| 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 |
 
 `*` All number literals allow `_` as a visual separator: `1_234.0E+18f64`
 
@@ -2467,12 +2467,6 @@ 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

branches/try/src/doc/trpl/unsafe.md

@@ -433,7 +433,6 @@ attribute attached to the crate.
 ```ignore
 // a minimal library
 #![crate_type="lib"]
-#![feature(no_std)]
 #![no_std]
 # // fn main() {} tricked you, rustdoc!
 ```
@@ -447,8 +446,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;
@@ -474,7 +473,6 @@ 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)]
@@ -530,8 +528,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;
@@ -578,6 +576,10 @@ 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
@@ -654,8 +656,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;
 

branches/try/src/liballoc/lib.rs

@@ -65,7 +65,6 @@
        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)]
@@ -127,8 +126,7 @@ pub fn oom() -> ! {
 #[doc(hidden)]
 pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
-// NOTE: remove after next snapshot
-#[cfg(all(stage0, not(test)))]
+#[cfg(not(test))]
 #[doc(hidden)]
 mod std {
     pub use core::fmt;

branches/try/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.")]

branches/try/src/libcollections/lib.rs

@@ -33,7 +33,6 @@
 #![cfg_attr(test, feature(test))]
 #![cfg_attr(test, allow(deprecated))] // rand
 
-#![feature(no_std)]
 #![no_std]
 
 #[macro_use]
@@ -69,7 +68,6 @@ mod bit;
 mod btree;
 pub mod dlist;
 pub mod enum_set;
-pub mod fmt;
 pub mod ring_buf;
 pub mod slice;
 pub mod str;
@@ -109,16 +107,15 @@ pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
 #[cfg(not(test))]
 mod std {
-    // 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::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)
     pub use core::ops;      // RangeFull
+    // for-loops
+    pub use core::iter;
 }
 
 #[cfg(test)]

branches/try/src/libcollections/macros.rs

@@ -22,19 +22,3 @@ 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)*)))
-}

branches/try/src/libcollections/ring_buf.rs

@@ -27,8 +27,8 @@ use core::ops::{Index, IndexMut};
 use core::ptr;
 use core::raw::Slice as RawSlice;
 
-use core::hash::{Writer, Hash, Hasher};
-use core::cmp;
+use std::hash::{Writer, Hash, Hasher};
+use std::cmp;
 
 use alloc::heap;
 

branches/try/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 marker::Sized;
+use std::marker::Sized;
 use usize;
 
 /// An interface for dealing with "external iterators". These types of iterators

branches/try/src/libcore/lib.rs

@@ -56,7 +56,6 @@
        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)]
@@ -149,25 +148,17 @@ 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 {
-    // 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 clone;
+    pub use cmp;
+    pub use fmt;
+    pub use hash;
+    pub use marker;
     pub use ops;
+    pub use option;
+    // for-loops
+    pub use iter;
 }

branches/try/src/libcore/marker.rs

@@ -311,17 +311,16 @@ impl<T: ?Sized> Clone for ContravariantType<T> {
 ///
 /// # Example
 ///
-/// The Cell type is an example of an `InvariantType` which uses unsafe
-/// code to achieve "interior" mutability:
+/// The Cell type is an example which uses unsafe code to achieve
+/// "interior" mutability:
 ///
 /// ```
 /// struct Cell<T> { value: T }
 /// ```
 ///
-/// The type system would infer that `value` is only read here
-/// and never written, but in fact `Cell` uses unsafe code to achieve
-/// interior mutability. In order to get correct behavior, the
-/// `InvariantType` marker must be applied.
+/// The type system would infer that `value` is only read here and
+/// never written, but in fact `Cell` uses unsafe code to achieve
+/// interior mutability.
 #[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="invariant_type"]

branches/try/src/liblibc/lib.rs

@@ -16,7 +16,6 @@
 #![cfg_attr(not(feature = "cargo-build"), staged_api)]
 #![cfg_attr(not(feature = "cargo-build"), feature(core))]
 #![feature(int_uint)]
-#![feature(no_std)]
 #![no_std]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
@@ -5730,9 +5729,8 @@ pub fn issue_14344_workaround() {} // FIXME #14344 force linkage to happen corre
 
 #[test] fn work_on_windows() { } // FIXME #10872 needed for a happy windows
 
-// NOTE: remove after next snapshot
 #[doc(hidden)]
-#[cfg(all(stage0, not(test)))]
+#[cfg(not(test))]
 mod std {
     pub use core::marker;
 }

branches/try/src/librand/lib.rs

@@ -23,7 +23,6 @@
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 #![feature(int_uint)]
-#![feature(no_std)]
 #![no_std]
 #![unstable(feature = "rand")]
 #![feature(staged_api)]
@@ -497,8 +496,7 @@ pub struct Open01<F>(pub F);
 /// ```
 pub struct Closed01<F>(pub F);
 
-// NOTE: remove after next snapshot
-#[cfg(all(stage0, not(test)))]
+#[cfg(not(test))]
 mod std {
     pub use core::{option, fmt}; // panic!()
     pub use core::clone; // derive Clone

branches/try/src/librustc/metadata/loader.rs

@@ -370,8 +370,9 @@ impl<'a> Context<'a> {
         // must be loaded via -L plus some filtering.
         if self.hash.is_none() {
             self.should_match_name = false;
-            if let Some(s) = self.sess.opts.externs.get(self.crate_name) {
-                return self.find_commandline_library(s);
+            match self.find_commandline_library() {
+                Some(l) => return Some(l),
+                None => {}
             }
             self.should_match_name = true;
         }
@@ -618,7 +619,12 @@ impl<'a> Context<'a> {
         (t.options.dll_prefix.clone(), t.options.dll_suffix.clone())
     }
 
-    fn find_commandline_library(&mut self, locs: &[String]) -> Option<Library> {
+    fn find_commandline_library(&mut self) -> Option<Library> {
+        let locs = match self.sess.opts.externs.get(self.crate_name) {
+            Some(s) => s,
+            None => return None,
+        };
+
         // First, filter out all libraries that look suspicious. We only accept
         // files which actually exist that have the correct naming scheme for
         // rlibs/dylibs.