auto merge of #13901 : alexcrichton/rust/facade, r=brson

This is the second step in implementing #13851. This PR cannot currently land until a snapshot exists with #13892, but I imagine that this review will take longer.

This PR refactors a large amount of functionality outside of the standard library into a new library, libcore. This new library has 0 dependencies (in theory). In practice, this library currently depends on these symbols being available:

* `rust_begin_unwind` and `rust_fail_bounds_check` - These are the two entry points of failure in libcore. The symbols are provided by libstd currently. In the future (see the bullets on #13851) this will be officially supported with nice error mesages. Additionally, there will only be one failure entry point once `std::fmt` migrates to libcore.
* `memcpy` - This is often generated by LLVM. This is also quite trivial to implement for any platform, so I'm not too worried about this.
* `memcmp` - This is required for comparing strings. This function is quite common *everywhere*, so I don't feel to bad about relying on a consumer of libcore to define it.
* `malloc` and `free` - This is quite unfortunate, and is a temporary stopgap until we deal with the `~` situation. More details can be found in the module `core::should_not_exist`
* `fmod` and `fmodf` - These exist because the `Rem` trait is defined in libcore, so the `Rem` implementation for floats must also be defined in libcore. I imagine that any platform using floating-point modulus will have these symbols anyway, and otherwise they will be optimized out.
* `fdim` and `fdimf` - Like `fmod`, these are from the `Signed` trait being defined in libcore. I don't expect this to be much of a problem

These dependencies all "Just Work" for now because libcore only exists as an rlib, not as a dylib.

The commits themselves are organized to show that the overall diff of this extraction is not all that large. Most modules were able to be moved with very few modifications. The primary module left out of this iteration is `std::fmt`. I plan on migrating the `fmt` module to libcore, but I chose to not do so at this time because it had implications on the `Writer` trait that I wanted to deal with in isolation. There are a few breaking changes in these commits, but they are fairly minor, and are all labeled with `[breaking-change]`.

The nastiest parts of this movement come up with `~[T]` and `~str` being language-defined types today. I believe that much of this nastiness will get better over time as we migrate towards `Vec<T>` and `Str` (or whatever the types will be named). There will likely always be some extension traits, but the situation won't be as bad as it is today.

Known deficiencies:

* rustdoc will get worse in terms of readability. This is the next issue I will tackle as part of #13851. If others think that the rustdoc change should happen first, I can also table this to fix rustdoc first.
* The compiler reveals that all these types are reexports via error messages like `core::option::Option`. This is filed as #13065, and I believe that issue would have a higher priority now. I do not currently plan on fixing that as part of #13851. If others believe that this issue should be fixed, I can also place it on the roadmap for #13851.

I recommend viewing these changes on a commit-by-commit basis. The overall change is likely too overwhelming to take in.

Author: bors

mk/crates.mk

@@ -51,12 +51,13 @@
 
 TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-		 workcache url log regex graphviz
+		 workcache url log regex graphviz core
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
-DEPS_std := libc native:rustrt native:compiler-rt native:backtrace
+DEPS_core :=
+DEPS_std := core libc native:rustrt native:compiler-rt native:backtrace
 DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
@@ -95,6 +96,8 @@ TOOL_SOURCE_compiletest := $(S)src/compiletest/compiletest.rs
 TOOL_SOURCE_rustdoc := $(S)src/driver/driver.rs
 TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
 
+ONLY_RLIB_core := 1
+
 ################################################################################
 # You should not need to edit below this line
 ################################################################################

mk/host.mk

@@ -18,6 +18,7 @@
 # $(5) - the name of the crate being processed
 define CP_HOST_STAGE_N_CRATE
 
+ifeq ($$(ONLY_RLIB_$(5)),)
 $$(HLIB$(2)_H_$(4))/stamp.$(5):					\
 	$$(TLIB$(1)_T_$(3)_H_$(4))/stamp.$(5)			\
 	$$(RUST_DEPS_$(5):%=$$(HLIB$(2)_H_$(4))/stamp.%)	\
@@ -30,6 +31,10 @@ $$(HLIB$(2)_H_$(4))/stamp.$(5):					\
 	        $$(HLIB$(2)_H_$(4))
 	$$(call LIST_ALL_OLD_GLOB_MATCHES,\
 	    $$(dir $$@)$$(call CFG_LIB_GLOB_$(3),$(5)))
+else
+$$(HLIB$(2)_H_$(4))/stamp.$(5):
+	$$(Q)touch $$@
+endif
 
 endef
 
@@ -54,9 +59,6 @@ endef
 # $(4) - the host triple (same as $(3))
 define CP_HOST_STAGE_N
 
-$$(HBIN$(2)_H_$(4))/:
-	@mkdir -p $$@
-
 ifneq ($(CFG_LIBDIR_RELATIVE),bin)
 $$(HLIB$(2)_H_$(4))/:
 	@mkdir -p $$@

src/doc/rust.md

@@ -3274,7 +3274,7 @@ The machine types are the following:
 
 * The signed two's complement word types `i8`, `i16`, `i32` and `i64`, with
   values drawn from the integer intervals [-(2^(7)), 2^7 - 1],
-  [-(2^(15)), 2^15 - 1], $[-(2^(31)), 2^31 - 1], [-(2^(63)), 2^63 - 1]
+  [-(2^(15)), 2^15 - 1], [-(2^(31)), 2^31 - 1], [-(2^(63)), 2^63 - 1]
   respectively.
 
 * The IEEE 754-2008 `binary32` and `binary64` floating-point types: `f32` and

src/libstd/any.rs renamed to src/libcore/any.rs

@@ -21,7 +21,6 @@
 //! the extension traits (`*Ext`) for the full details.
 
 use cast::{transmute, transmute_copy};
-use fmt;
 use option::{Option, Some, None};
 use owned::Box;
 use raw::TraitObject;
@@ -145,28 +144,12 @@ impl AnyOwnExt for Box<Any> {
     }
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// Trait implementations
-///////////////////////////////////////////////////////////////////////////////
-
-impl fmt::Show for Box<Any> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.pad("Box<Any>")
-    }
-}
-
-impl<'a> fmt::Show for &'a Any {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.pad("&Any")
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use prelude::*;
     use super::*;
     use owned::Box;
-    use str::StrSlice;
+    use realstd::str::StrAllocating;
 
     #[deriving(Eq, Show)]
     struct Test;
@@ -291,13 +274,13 @@ mod tests {
 
     #[test]
     fn test_show() {
-        let a = box 8u as Box<Any>;
-        let b = box Test as Box<Any>;
+        let a = box 8u as Box<::realcore::any::Any>;
+        let b = box Test as Box<::realcore::any::Any>;
         assert_eq!(format!("{}", a), "Box<Any>".to_owned());
         assert_eq!(format!("{}", b), "Box<Any>".to_owned());
 
-        let a = &8u as &Any;
-        let b = &Test as &Any;
+        let a = &8u as &::realcore::any::Any;
+        let b = &Test as &::realcore::any::Any;
         assert_eq!(format!("{}", a), "&Any".to_owned());
         assert_eq!(format!("{}", b), "&Any".to_owned());
     }

src/libstd/bool.rs renamed to src/libcore/bool.rs

@@ -14,7 +14,6 @@
 //!
 //! Implementations of the following traits:
 //!
-//! * `FromStr`
 //! * `Not`
 //! * `Ord`
 //! * `TotalOrd`
@@ -24,11 +23,9 @@
 //!
 //! A `to_bit` conversion function.
 
-use from_str::FromStr;
 use num::{Int, one, zero};
-use option::{None, Option, Some};
 
-#[cfg(not(test))] use cmp::{Eq, Ord, TotalOrd, Ordering};
+#[cfg(not(test))] use cmp::{Eq, Ord, TotalOrd, Ordering, TotalEq};
 #[cfg(not(test))] use ops::{Not, BitAnd, BitOr, BitXor};
 #[cfg(not(test))] use default::Default;
 
@@ -55,28 +52,6 @@ pub fn to_bit<N: Int>(p: bool) -> N {
 // Trait impls on `bool`
 /////////////////////////////////////////////////////////////////////////////
 
-impl FromStr for bool {
-    /// Parse a `bool` from a string.
-    ///
-    /// Yields an `Option<bool>`, because `s` may or may not actually be parseable.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// assert_eq!(from_str::<bool>("true"), Some(true));
-    /// assert_eq!(from_str::<bool>("false"), Some(false));
-    /// assert_eq!(from_str::<bool>("not even a boolean"), None);
-    /// ```
-    #[inline]
-    fn from_str(s: &str) -> Option<bool> {
-        match s {
-            "true"  => Some(true),
-            "false" => Some(false),
-            _       => None,
-        }
-    }
-}
-
 #[cfg(not(test))]
 impl Not<bool> for bool {
     /// The logical complement of a boolean value.
@@ -190,16 +165,18 @@ impl Eq for bool {
     fn eq(&self, other: &bool) -> bool { (*self) == (*other) }
 }
 
+#[cfg(not(test))]
+impl TotalEq for bool {}
+
 #[cfg(not(test))]
 impl Default for bool {
     fn default() -> bool { false }
 }
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
+    use realstd::prelude::*;
     use super::to_bit;
-    use str::StrSlice;
 
     #[test]
     fn test_to_bit() {
@@ -260,13 +237,6 @@ mod tests {
         assert_eq!(!false, true);
     }
 
-    #[test]
-    fn test_from_str() {
-        assert_eq!(from_str::<bool>("true"), Some(true));
-        assert_eq!(from_str::<bool>("false"), Some(false));
-        assert_eq!(from_str::<bool>("not even a boolean"), None);
-    }
-
     #[test]
     fn test_to_str() {
         assert_eq!(false.to_str(), "false".to_owned());

src/libstd/cast.rs renamed to src/libcore/cast.rs

@@ -108,7 +108,7 @@ pub unsafe fn copy_lifetime_vec<'a,S,T>(_ptr: &'a [S], ptr: &T) -> &'a T {
 mod tests {
     use cast::{bump_box_refcount, transmute};
     use raw;
-    use str::StrSlice;
+    use realstd::str::StrAllocating;
 
     #[test]
     fn test_transmute_copy() {

src/libstd/cell.rs renamed to src/libcore/cell.rs

@@ -12,7 +12,6 @@
 
 use clone::Clone;
 use cmp::Eq;
-use fmt;
 use kinds::{marker, Copy};
 use ops::{Deref, DerefMut, Drop};
 use option::{None, Option, Some};
@@ -60,12 +59,6 @@ impl<T:Eq + Copy> Eq for Cell<T> {
     }
 }
 
-impl<T: Copy + fmt::Show> fmt::Show for Cell<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, r"Cell \{ value: {} \}", self.get())
-    }
-}
-
 /// A mutable memory location with dynamically checked borrow rules
 pub struct RefCell<T> {
     value: Unsafe<T>,
@@ -228,22 +221,22 @@ mod test {
     #[test]
     fn smoketest_cell() {
         let x = Cell::new(10);
-        assert_eq!(x, Cell::new(10));
-        assert_eq!(x.get(), 10);
+        assert!(x == Cell::new(10));
+        assert!(x.get() == 10);
         x.set(20);
-        assert_eq!(x, Cell::new(20));
-        assert_eq!(x.get(), 20);
+        assert!(x == Cell::new(20));
+        assert!(x.get() == 20);
 
         let y = Cell::new((30, 40));
-        assert_eq!(y, Cell::new((30, 40)));
-        assert_eq!(y.get(), (30, 40));
+        assert!(y == Cell::new((30, 40)));
+        assert!(y.get() == (30, 40));
     }
 
     #[test]
     fn cell_has_sensible_show() {
         use str::StrSlice;
 
-        let x = Cell::new("foo bar");
+        let x = ::realcore::cell::Cell::new("foo bar");
         assert!(format!("{}", x).contains(x.get()));
 
         x.set("baz qux");