Don't use std:: paths in syntax extensions when compiling a #![no_std] crate

Fixes #16803.

Author: Keegan McAllister

src/liballoc/lib.rs

@@ -124,7 +124,8 @@ fn oom() -> ! {
 #[doc(hidden)]
 pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
-#[cfg(not(test))]
+// NOTE: Remove after next snapshot
+#[cfg(stage0, not(test))]
 #[doc(hidden)]
 mod std {
     pub use core::fmt;

src/libcollections/bitv.rs

@@ -70,10 +70,10 @@ use core::iter::{Chain, Enumerate, Repeat, Skip, Take};
 use core::iter;
 use core::slice;
 use core::uint;
-use std::hash;
 
 use {Mutable, Set, MutableSet, MutableSeq};
 use vec::Vec;
+use hash;
 
 type MatchWords<'a> = Chain<MaskWords<'a>, Skip<Take<Enumerate<Repeat<uint>>>>>;
 // Take two BitV's, and return iterators of their words, where the shorter one

src/libcollections/dlist.rs

@@ -29,9 +29,9 @@ use core::fmt;
 use core::iter;
 use core::mem;
 use core::ptr;
-use std::hash::{Writer, Hash};
 
 use {Mutable, Deque, MutableSeq};
+use hash::{Writer, Hash};
 
 /// A doubly-linked list.
 pub struct DList<T> {
@@ -742,13 +742,13 @@ impl<S: Writer, A: Hash<S>> Hash<S> for DList<A> {
 mod tests {
     use std::prelude::*;
     use std::rand;
-    use std::hash;
     use test::Bencher;
     use test;
 
     use {Deque, MutableSeq};
     use super::{DList, Node, ListInsertion};
     use vec::Vec;
+    use hash;
 
     pub fn check_links<T>(list: &DList<T>) {
         let mut len = 0u;

src/libcollections/lib.rs

@@ -558,13 +558,20 @@ 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::option;   // necessary for fail!()
+    #[cfg(stage0)] pub use core::clone;    // deriving(Clone)
+    #[cfg(stage0)] pub use core::cmp;      // deriving(Eq, Ord, etc.)
+    #[cfg(stage0)] pub use hash;           // deriving(Hash)
+
     pub use core::fmt;      // necessary for fail!()
-    pub use core::option;   // necessary for fail!()
-    pub use core::clone;    // deriving(Clone)
-    pub use core::cmp;      // deriving(Eq, Ord, etc.)
-    pub use hash;           // deriving(Hash)
 
+    #[cfg(stage0)]
     pub mod collections {
         pub use MutableSeq;
     }
 }
+
+mod collections {
+    pub use hash;  // deriving(Hsah)
+}

src/libcollections/ringbuf.rs

@@ -19,10 +19,10 @@ use core::cmp;
 use core::default::Default;
 use core::fmt;
 use core::iter;
-use std::hash::{Writer, Hash};
 
 use {Deque, Mutable, MutableSeq};
 use vec::Vec;
+use hash::{Writer, Hash};
 
 static INITIAL_CAPACITY: uint = 8u; // 2^3
 static MINIMUM_CAPACITY: uint = 2u;
@@ -527,13 +527,13 @@ mod tests {
     use std::fmt::Show;
     use std::prelude::*;
     use std::gc::{GC, Gc};
-    use std::hash;
     use test::Bencher;
     use test;
 
     use {Deque, Mutable, MutableSeq};
     use super::RingBuf;
     use vec::Vec;
+    use hash;
 
     #[test]
     fn test_simple() {

src/libcollections/treemap.rs

@@ -38,10 +38,10 @@ use core::iter::Peekable;
 use core::iter;
 use core::mem::{replace, swap};
 use core::ptr;
-use std::hash::{Writer, Hash};
 
 use {Mutable, Set, MutableSet, MutableMap, Map, MutableSeq};
 use vec::Vec;
+use hash::{Writer, Hash};
 
 /// This is implemented as an AA tree, which is a simplified variation of
 /// a red-black tree where red (horizontal) nodes can only be added
@@ -2248,10 +2248,10 @@ mod bench {
 #[cfg(test)]
 mod test_set {
     use std::prelude::*;
-    use std::hash;
 
     use {Set, MutableSet, Mutable, MutableMap, MutableSeq};
     use super::{TreeMap, TreeSet};
+    use hash;
 
     #[test]
     fn test_clear() {

src/libcollections/trie.rs

@@ -21,11 +21,11 @@ use core::mem::zeroed;
 use core::mem;
 use core::uint;
 use core::iter;
-use std::hash::{Writer, Hash};
 
 use {Mutable, Map, MutableMap, Set, MutableSet};
 use slice::{Items, MutItems};
 use slice;
+use hash::{Writer, Hash};
 
 // FIXME: #5244: need to manually update the TrieNode constructor
 static SHIFT: uint = 4;
@@ -1019,10 +1019,10 @@ mod test_map {
     use std::prelude::*;
     use std::iter::range_step;
     use std::uint;
-    use std::hash;
 
     use {MutableMap, Map, MutableSeq};
     use super::{TrieMap, TrieNode, Internal, External, Nothing};
+    use hash;
 
     fn check_integrity<T>(trie: &TrieNode<T>) {
         assert!(trie.count != 0);

src/libcore/atomic.rs

@@ -13,7 +13,7 @@
 #![stable]
 
 use intrinsics;
-use std::kinds::marker;
+use kinds::marker;
 use cell::UnsafeCell;
 
 /// An atomic boolean type.

src/libcore/lib.rs

@@ -134,12 +134,19 @@ pub mod unit;
 pub mod fmt;
 
 #[doc(hidden)]
-mod core {
-    pub use failure;
+mod std {
+    // NOTE: Remove after next snapshot
+    #[cfg(stage0)] pub use clone;
+    #[cfg(stage0)] pub use cmp;
+    #[cfg(stage0)] pub use kinds;
+    #[cfg(stage0)] pub use option;
+
+    pub use fmt;
 }
 
 #[doc(hidden)]
-mod std {
+mod core {
+    pub use failure;
     pub use clone;
     pub use cmp;
     pub use kinds;

src/libcore/result.rs

@@ -278,7 +278,7 @@
 
 use clone::Clone;
 use cmp::PartialEq;
-use std::fmt::Show;
+use fmt::Show;
 use slice;
 use slice::Slice;
 use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSize};

src/librustc/driver/driver.rs

@@ -273,6 +273,7 @@ pub fn phase_2_configure_and_expand(sess: &Session,
             let cfg = syntax::ext::expand::ExpansionConfig {
                 deriving_hash_type_parameter: sess.features.default_type_params.get(),
                 crate_name: crate_name.to_string(),
+                use_std: front::std_inject::use_std(&krate),
             };
             let ret = syntax::ext::expand::expand_crate(&sess.parse_sess,
                                               cfg,

src/librustc/front/std_inject.rs

@@ -43,7 +43,7 @@ pub fn maybe_inject_prelude(sess: &Session, krate: ast::Crate) -> ast::Crate {
     }
 }
 
-fn use_std(krate: &ast::Crate) -> bool {
+pub fn use_std(krate: &ast::Crate) -> bool {
     !attr::contains_name(krate.attrs.as_slice(), "no_std")
 }
 

src/librustc/front/test.rs

@@ -14,7 +14,7 @@
 #![allow(unused_imports)]
 
 use driver::session::Session;
-use front::config;
+use front::{config, std_inject};
 
 use std::slice;
 use std::mem;
@@ -232,6 +232,7 @@ fn generate_test_harness(sess: &Session,
                              ExpansionConfig {
                                  deriving_hash_type_parameter: false,
                                  crate_name: "test".to_string(),
+                                 use_std: std_inject::use_std(&krate),
                              }),
         path: Vec::new(),
         testfns: Vec::new(),

src/librustrt/lib.rs

@@ -166,5 +166,8 @@ pub mod shouldnt_be_public {
 
 #[cfg(not(test))]
 mod std {
-    pub use core::{fmt, option, cmp};
+    // NOTE: Remove after next snapshot
+    #[cfg(stage0)] pub use core::{option, cmp};
+
+    pub use core::fmt;
 }

src/libstd/lib.rs

@@ -273,12 +273,13 @@ mod failure;
 #[doc(hidden)]
 mod std {
     // mods used for deriving
-    pub use clone;
-    pub use cmp;
-    pub use hash;
+    // NOTE: Remove after next snapshot
+    #[cfg(stage0)] pub use clone;
+    #[cfg(stage0)] pub use cmp;
+    #[cfg(stage0)] pub use hash;
 
     pub use comm; // used for select!()
-    pub use fmt; // used for any formatting strings
+    pub use fmt; // used for fail!()
     pub use io; // used for println!()
     pub use local_data; // used for local_data_key!()
     pub use option; // used for bitflags!{}

src/libstd/num/strconv.rs

@@ -21,7 +21,7 @@ use num;
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use option::{None, Option, Some};
 use slice::{ImmutableSlice, MutableSlice};
-use std::cmp::{PartialOrd, PartialEq};
+use cmp::{PartialOrd, PartialEq};
 use str::StrSlice;
 use string::String;
 use vec::Vec;

src/libsync/lib.rs

@@ -76,5 +76,8 @@ mod lock;
 
 #[cfg(not(test))]
 mod std {
-    pub use core::{fmt, option, cmp, clone};
+    // NOTE: Remove after next snapshot
+    #[cfg(stage0)] pub use core::{option, cmp, clone};
+
+    pub use core::fmt;  // for fail!()
 }

src/libsyntax/ext/base.rs

@@ -588,6 +588,9 @@ impl<'a> ExtCtxt<'a> {
     pub fn ident_of(&self, st: &str) -> ast::Ident {
         str_to_ident(st)
     }
+    pub fn ident_of_std(&self, st: &str) -> ast::Ident {
+        self.ident_of(if self.ecfg.use_std { "std" } else { st })
+    }
     pub fn name_of(&self, st: &str) -> ast::Name {
         token::intern(st)
     }