OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

std: Rename Show/String to Debug/Display 

This commit is an implementation of [RFC 565][rfc] which is a stabilization of
the `std::fmt` module and the implementations of various formatting traits.
Specifically, the following changes were performed:

[rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0565-show-string-guidelines.md

* The `Show` trait is now deprecated, it was renamed to `Debug`
* The `String` trait is now deprecated, it was renamed to `Display`
* Many `Debug` and `Display` implementations were audited in accordance with the
  RFC and audited implementations now have the `#[stable]` attribute
  * Integers and floats no longer print a suffix
  * Smart pointers no longer print details that they are a smart pointer
  * Paths with `Debug` are now quoted and escape characters
* The `unwrap` methods on `Result` now require `Display` instead of `Debug`
* The `Error` trait no longer has a `detail` method and now requires that
  `Display` must be implemented. With the loss of `String`, this has moved into
  libcore.
* `impl<E: Error> FromError<E> for Box<Error>` now exists
* `derive(Show)` has been renamed to `derive(Debug)`. This is not currently
  warned about due to warnings being emitted on stage1+

While backwards compatibility is attempted to be maintained with a blanket
implementation of `Display` for the old `String` trait (and the same for
`Show`/`Debug`) this is still a breaking change due to primitives no longer
implementing `String` as well as modifications such as `unwrap` and the `Error`
trait. Most code is fairly straightforward to update with a rename or tweaks of
method calls.

[breaking-change]
Closes #21436
This commit is contained in:
Alex Crichton 2015-01-20 15:45:07 -08:00
parent 29bd9a06ef
commit 3cb9fa26ef
136 changed files with 763 additions and 706 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/compiletest/common.rs
View File

@ -13,7 +13,7 @@ use std::fmt;
use std::str::FromStr;
use regex::Regex;
#[derive(Clone, PartialEq)]
#[derive(Clone, PartialEq, Debug)]
pub enum Mode {
CompileFail,
RunFail,
@ -43,9 +43,9 @@ impl FromStr for Mode {
}
}
impl fmt::String for Mode {
impl fmt::Display for Mode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(match *self {
fmt::Display::fmt(match *self {
CompileFail => "compile-fail",
RunFail => "run-fail",
RunPass => "run-pass",
@ -58,12 +58,6 @@ impl fmt::String for Mode {
}
}
impl fmt::Show for Mode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
}
}
#[derive(Clone)]
pub struct Config {
// The library paths required for running the compiler

6
src/compiletest/runtest.rs
View File

@ -547,7 +547,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
// Add line breakpoints
for line in breakpoint_lines.iter() {
script_str.push_str(&format!("break '{:?}':{}\n",
script_str.push_str(&format!("break '{}':{}\n",
testfile.filename_display(),
*line)[]);
}
@ -750,7 +750,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
status: status,
stdout: out,
stderr: err,
cmdline: format!("{}", cmd)
cmdline: format!("{:?}", cmd)
};
}
}
@ -953,7 +953,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
}
let prefixes = expected_errors.iter().map(|ee| {
format!("{:?}:{}:", testfile.display(), ee.line)
format!("{}:{}:", testfile.display(), ee.line)
}).collect::<Vec<String> >();
#[cfg(windows)]

13
src/liballoc/arc.rs
View File

@ -72,7 +72,7 @@ use core::prelude::*;
use core::atomic;
use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst};
use core::borrow::BorrowFrom;
use core::fmt::{self, Show};
use core::fmt;
use core::cmp::{Ordering};
use core::default::Default;
use core::mem::{min_align_of, size_of};
@ -578,16 +578,17 @@ impl<T: Ord> Ord for Arc<T> {
#[stable]
impl<T: Eq> Eq for Arc<T> {}
impl<T: fmt::Show> fmt::Show for Arc<T> {
#[stable]
impl<T: fmt::Display> fmt::Display for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Arc({:?})", (**self))
fmt::Display::fmt(&**self, f)
}
}
#[stable]
impl<T: fmt::String> fmt::String for Arc<T> {
impl<T: fmt::Debug> fmt::Debug for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&**self, f)
fmt::Debug::fmt(&**self, f)
}
}
@ -806,7 +807,7 @@ mod tests {
#[test]
fn show_arc() {
let a = Arc::new(5u32);
assert!(format!("{:?}", a) == "Arc(5u32)")
assert_eq!(format!("{:?}", a), "5");
}
// Make sure deriving works with Arc<T>

23
src/liballoc/boxed.rs
View File

@ -16,16 +16,17 @@ use core::any::Any;
use core::clone::Clone;
use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
use core::default::Default;
use core::error::{Error, FromError};
use core::fmt;
use core::hash::{self, Hash};
use core::marker::Sized;
use core::mem;
use core::ops::{Deref, DerefMut};
use core::option::Option;
use core::ptr::Unique;
use core::raw::TraitObject;
use core::result::Result;
use core::result::Result::{Ok, Err};
use core::ops::{Deref, DerefMut};
use core::result::Result;
/// A value that represents the global exchange heap. This is the default
/// place that the `box` keyword allocates into when no place is supplied.
@ -156,20 +157,22 @@ impl BoxAny for Box<Any> {
}
}
impl<T: ?Sized + fmt::Show> fmt::Show for Box<T> {
#[stable]
impl<T: fmt::Display + ?Sized> fmt::Display for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Box({:?})", &**self)
fmt::Display::fmt(&**self, f)
}
}
#[stable]
impl<T: ?Sized + fmt::String> fmt::String for Box<T> {
impl<T: fmt::Debug + ?Sized> fmt::Debug for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&**self, f)
fmt::Debug::fmt(&**self, f)
}
}
impl fmt::Show for Box<Any> {
#[stable]
impl fmt::Debug for Box<Any> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.pad("Box<Any>")
}
@ -187,6 +190,12 @@ impl<T: ?Sized> DerefMut for Box<T> {
fn deref_mut(&mut self) -> &mut T { &mut **self }
}
impl<'a, E: Error + 'a> FromError<E> for Box<Error + 'a> {
fn from_error(err: E) -> Box<Error + 'a> {
Box::new(err)
}
}
#[cfg(test)]
mod test {
#[test]

16
src/liballoc/rc.rs
View File

@ -693,17 +693,17 @@ impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> {
}
}
#[unstable = "Show is experimental."]
impl<T: fmt::Show> fmt::Show for Rc<T> {
#[stable]
impl<T: fmt::Display> fmt::Display for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Rc({:?})", **self)
fmt::Display::fmt(&**self, f)
}
}
#[stable]
impl<T: fmt::String> fmt::String for Rc<T> {
impl<T: fmt::Debug> fmt::Debug for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&**self, f)
fmt::Debug::fmt(&**self, f)
}
}
@ -890,8 +890,8 @@ impl<T> Clone for Weak<T> {
}
}
#[unstable = "Show is experimental."]
impl<T: fmt::Show> fmt::Show for Weak<T> {
#[stable]
impl<T: fmt::Debug> fmt::Debug for Weak<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "(Weak)")
}
@ -1134,7 +1134,7 @@ mod tests {
#[test]
fn test_show() {
let foo = Rc::new(75u);
assert!(format!("{:?}", foo) == "Rc(75u)")
assert_eq!(format!("{:?}", foo), "75");
}
}

6
src/libcollections/bit.rs
View File

@ -972,7 +972,7 @@ impl Ord for Bitv {
}
#[stable]
impl fmt::Show for Bitv {
impl fmt::Debug for Bitv {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
for bit in self.iter() {
try!(write!(fmt, "{}", if bit { 1u32 } else { 0u32 }));
@ -1727,7 +1727,7 @@ impl BitvSet {
}
}
impl fmt::Show for BitvSet {
impl fmt::Debug for BitvSet {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
try!(write!(fmt, "BitvSet {{"));
let mut first = true;
@ -2622,7 +2622,7 @@ mod bitv_set_test {
s.insert(10);
s.insert(50);
s.insert(2);
assert_eq!("BitvSet {1u, 2u, 10u, 50u}", format!("{:?}", s));
assert_eq!("BitvSet {1, 2, 10, 50}", format!("{:?}", s));
}
#[test]

4
src/libcollections/btree/map.rs
View File

@ -22,7 +22,7 @@ use core::prelude::*;
use core::borrow::BorrowFrom;
use core::cmp::Ordering;
use core::default::Default;
use core::fmt::Show;
use core::fmt::Debug;
use core::hash::{Hash, Hasher};
use core::iter::{Map, FromIterator};
use core::ops::{Index, IndexMut};
@ -871,7 +871,7 @@ impl<K: Ord, V: Ord> Ord for BTreeMap<K, V> {
}
#[stable]
impl<K: Show, V: Show> Show for BTreeMap<K, V> {
impl<K: Debug, V: Debug> Debug for BTreeMap<K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "BTreeMap {{"));

6
src/libcollections/btree/set.rs
View File

@ -16,7 +16,7 @@ use core::prelude::*;
use core::borrow::BorrowFrom;
use core::cmp::Ordering::{self, Less, Greater, Equal};
use core::default::Default;
use core::fmt::Show;
use core::fmt::Debug;
use core::fmt;
// NOTE(stage0) remove import after a snapshot
#[cfg(stage0)]
@ -592,7 +592,7 @@ impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> {
}
#[stable]
impl<T: Show> Show for BTreeSet<T> {
impl<T: Debug> Debug for BTreeSet<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "BTreeSet {{"));
@ -892,7 +892,7 @@ mod test {
let set_str = format!("{:?}", set);
assert_eq!(set_str, "BTreeSet {1i, 2i}");
assert_eq!(set_str, "BTreeSet {1, 2}");
assert_eq!(format!("{:?}", empty), "BTreeSet {}");
}
}

4
src/libcollections/dlist.rs
View File

@ -874,7 +874,7 @@ impl<A: Clone> Clone for DList<A> {
}
#[stable]
impl<A: fmt::Show> fmt::Show for DList<A> {
impl<A: fmt::Debug> fmt::Debug for DList<A> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "DList ["));
@ -1333,7 +1333,7 @@ mod tests {
#[test]
fn test_show() {
let list: DList<int> = range(0i, 10).collect();
assert_eq!(format!("{:?}", list), "DList [0i, 1i, 2i, 3i, 4i, 5i, 6i, 7i, 8i, 9i]");
assert_eq!(format!("{:?}", list), "DList [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
let list: DList<&str> = vec!["just", "one", "test", "more"].iter()
.map(|&s| s)

2
src/libcollections/enum_set.rs
View File

@ -31,7 +31,7 @@ pub struct EnumSet<E> {
impl<E> Copy for EnumSet<E> {}
impl<E:CLike+fmt::Show> fmt::Show for EnumSet<E> {
impl<E:CLike + fmt::Debug> fmt::Debug for EnumSet<E> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
try!(write!(fmt, "EnumSet {{"));
let mut first = true;

8
src/libcollections/ring_buf.rs
View File

@ -1611,7 +1611,7 @@ impl<A> Extend<A> for RingBuf<A> {
}
#[stable]
impl<T: fmt::Show> fmt::Show for RingBuf<T> {
impl<T: fmt::Debug> fmt::Debug for RingBuf<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "RingBuf ["));
@ -1630,7 +1630,7 @@ mod tests {
use self::Taggypar::*;
use prelude::*;
use core::iter;
use std::fmt::Show;
use std::fmt::Debug;
use std::hash::{self, SipHasher};
use test::Bencher;
use test;
@ -1678,7 +1678,7 @@ mod tests {
}
#[cfg(test)]
fn test_parameterized<T:Clone + PartialEq + Show>(a: T, b: T, c: T, d: T) {
fn test_parameterized<T:Clone + PartialEq + Debug>(a: T, b: T, c: T, d: T) {
let mut deq = RingBuf::new();
assert_eq!(deq.len(), 0);
deq.push_front(a.clone());
@ -2302,7 +2302,7 @@ mod tests {
#[test]
fn test_show() {
let ringbuf: RingBuf<int> = range(0i, 10).collect();
assert_eq!(format!("{:?}", ringbuf), "RingBuf [0i, 1i, 2i, 3i, 4i, 5i, 6i, 7i, 8i, 9i]");
assert_eq!(format!("{:?}", ringbuf), "RingBuf [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
let ringbuf: RingBuf<&str> = vec!["just", "one", "test", "more"].iter()
.map(|&s| s)

12
src/libcollections/slice.rs
View File

@ -2476,19 +2476,19 @@ mod tests {
}
let empty: Vec<int> = vec![];
test_show_vec!(empty, "[]");
test_show_vec!(vec![1i], "[1i]");
test_show_vec!(vec![1i, 2, 3], "[1i, 2i, 3i]");
test_show_vec!(vec![1i], "[1]");
test_show_vec!(vec![1i, 2, 3], "[1, 2, 3]");
test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]],
"[[], [1u], [1u, 1u]]");
"[[], [1], [1, 1]]");
let empty_mut: &mut [int] = &mut[];
test_show_vec!(empty_mut, "[]");
let v: &mut[int] = &mut[1];
test_show_vec!(v, "[1i]");
test_show_vec!(v, "[1]");
let v: &mut[int] = &mut[1, 2, 3];
test_show_vec!(v, "[1i, 2i, 3i]");
test_show_vec!(v, "[1, 2, 3]");
let v: &mut [&mut[uint]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]];
test_show_vec!(v, "[[], [1u], [1u, 1u]]");
test_show_vec!(v, "[[], [1], [1, 1]]");
}
#[test]

43
src/libcollections/string.rs
View File

@ -18,6 +18,7 @@ use core::prelude::*;
use core::borrow::{Cow, IntoCow};
use core::default::Default;
use core::error::Error;
use core::fmt;
use core::hash;
use core::iter::FromIterator;
@ -40,6 +41,7 @@ pub struct String {
/// A possible error value from the `String::from_utf8` function.
#[stable]
#[derive(Show)]
pub struct FromUtf8Error {
bytes: Vec<u8>,
error: Utf8Error,
@ -48,6 +50,7 @@ pub struct FromUtf8Error {
/// A possible error value from the `String::from_utf16` function.
#[stable]
#[allow(missing_copy_implementations)]
#[derive(Show)]
pub struct FromUtf16Error(());
impl String {
@ -680,30 +683,28 @@ impl FromUtf8Error {
pub fn utf8_error(&self) -> Utf8Error { self.error }
}
impl fmt::Show for FromUtf8Error {
#[stable]
impl fmt::Display for FromUtf8Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
fmt::Display::fmt(&self.error, f)
}
}
#[stable]
impl fmt::String for FromUtf8Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&self.error, f)
}
impl Error for FromUtf8Error {
fn description(&self) -> &str { "invalid utf-8" }
}
impl fmt::Show for FromUtf16Error {
#[stable]
impl fmt::Display for FromUtf16Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
fmt::Display::fmt("invalid utf-16: lone surrogate found", f)
}
}
#[stable]
impl fmt::String for FromUtf16Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt("invalid utf-16: lone surrogate found", f)
}
impl Error for FromUtf16Error {
fn description(&self) -> &str { "invalid utf-16" }
}
#[stable]
@ -814,18 +815,18 @@ impl Default for String {
}
#[stable]
impl fmt::String for String {
impl fmt::Display for String {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&**self, f)
fmt::Display::fmt(&**self, f)
}
}
#[unstable = "waiting on fmt stabilization"]
impl fmt::Show for String {
#[stable]
impl fmt::Debug for String {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(&**self, f)
fmt::Debug::fmt(&**self, f)
}
}
@ -934,7 +935,7 @@ pub trait ToString {
fn to_string(&self) -> String;
}
impl<T: fmt::String + ?Sized> ToString for T {
impl<T: fmt::Display + ?Sized> ToString for T {
#[inline]
fn to_string(&self) -> String {
use core::fmt::Writer;
@ -1295,10 +1296,10 @@ mod tests {
fn test_vectors() {
let x: Vec<int> = vec![];
assert_eq!(format!("{:?}", x), "[]");
assert_eq!(format!("{:?}", vec![1i]), "[1i]");
assert_eq!(format!("{:?}", vec![1i, 2, 3]), "[1i, 2i, 3i]");
assert_eq!(format!("{:?}", vec![1i]), "[1]");
assert_eq!(format!("{:?}", vec![1i, 2, 3]), "[1, 2, 3]");
assert!(format!("{:?}", vec![vec![], vec![1i], vec![1i, 1]]) ==
"[[], [1i], [1i, 1i]]");
"[[], [1], [1, 1]]");
}
#[test]

6
src/libcollections/vec.rs
View File

@ -1486,10 +1486,10 @@ impl<T> Default for Vec<T> {
}
}
#[unstable = "waiting on Show stability"]
impl<T: fmt::Show> fmt::Show for Vec<T> {
#[stable]
impl<T: fmt::Debug> fmt::Debug for Vec<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(self.as_slice(), f)
fmt::Debug::fmt(self.as_slice(), f)
}
}

4
src/libcollections/vec_map.rs
View File

@ -513,7 +513,7 @@ impl<V: Ord> Ord for VecMap<V> {
}
#[stable]
impl<V: fmt::Show> fmt::Show for VecMap<V> {
impl<V: fmt::Debug> fmt::Debug for VecMap<V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "VecMap {{"));
@ -990,7 +990,7 @@ mod test_map {
map.insert(3, 4i);
let map_str = format!("{:?}", map);
assert!(map_str == "VecMap {1: 2i, 3: 4i}" || map_str == "{3: 4i, 1: 2i}");
assert!(map_str == "VecMap {1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}");
assert_eq!(format!("{:?}", empty), "VecMap {}");
}

8
src/libcore/any.rs
View File

@ -34,11 +34,11 @@
//! use runtime reflection instead.
//!
//! ```rust
//! use std::fmt::Show;
//! use std::fmt::Debug;
//! use std::any::Any;
//!
//! // Logger function for any type that implements Show.
//! fn log<T: Any+Show>(value: &T) {
//! // Logger function for any type that implements Debug.
//! fn log<T: Any + Debug>(value: &T) {
//! let value_any = value as &Any;
//!
//! // try to convert our value to a String. If successful, we want to
@ -55,7 +55,7 @@
//! }
//!
//! // This function wants to log its parameter out prior to doing work with it.
//! fn do_work<T: Show+'static>(value: &T) {
//! fn do_work<T: Debug + 'static>(value: &T) {
//! log(value);
//! // ...do some other work
//! }

6
src/libcore/array.rs
View File

@ -39,10 +39,10 @@ macro_rules! array_impls {
}
}
#[unstable = "waiting for Show to stabilize"]
impl<T:fmt::Show> fmt::Show for [T; $N] {
#[stable]
impl<T: fmt::Debug> fmt::Debug for [T; $N] {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(&&self[], f)
fmt::Debug::fmt(&&self[], f)
}
}

24
src/libcore/borrow.rs
View File

@ -133,7 +133,6 @@ impl<T> ToOwned<T> for T where T: Clone {
/// }
/// }
/// ```
#[derive(Show)]
pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> {
/// Borrowed data.
Borrowed(&'a B),
@ -239,14 +238,27 @@ impl<'a, T, B: ?Sized> PartialOrd for Cow<'a, T, B> where B: PartialOrd + ToOwne
}
#[stable]
impl<'a, T, B: ?Sized> fmt::String for Cow<'a, T, B> where
B: fmt::String + ToOwned<T>,
T: fmt::String,
impl<'a, T, B: ?Sized> fmt::Debug for Cow<'a, T, B> where
B: fmt::Debug + ToOwned<T>,
T: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Borrowed(ref b) => fmt::String::fmt(b, f),
Owned(ref o) => fmt::String::fmt(o, f),
Borrowed(ref b) => fmt::Debug::fmt(b, f),
Owned(ref o) => fmt::Debug::fmt(o, f),
}
}
}
#[stable]
impl<'a, T, B: ?Sized> fmt::Display for Cow<'a, T, B> where
B: fmt::Display + ToOwned<T>,
T: fmt::Display,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Borrowed(ref b) => fmt::Display::fmt(b, f),
Owned(ref o) => fmt::Display::fmt(o, f),
}
}
}

43
src/libstd/error.rs → src/libcore/error.rs
View File

@ -14,14 +14,15 @@
//!
//! `Error` is a trait representing the basic expectations for error values,
//! i.e. values of type `E` in `Result<T, E>`. At a minimum, errors must provide
//! a description, but they may optionally provide additional detail and cause
//! chain information:
//! a description, but they may optionally provide additional detail (via
//! `Display`) and cause chain information:
//!
//! ```
//! trait Error {
//! use std::fmt::Display;
//!
//! trait Error: Display {
//! fn description(&self) -> &str;
//!
//! fn detail(&self) -> Option<String> { None }
//! fn cause(&self) -> Option<&Error> { None }
//! }
//! ```
@ -80,20 +81,15 @@
#![stable]
use prelude::v1::*;
use str::Utf8Error;
use string::{FromUtf8Error, FromUtf16Error};
use prelude::*;
use fmt::Display;
/// Base functionality for all errors in Rust.
#[unstable = "the exact API of this trait may change"]
pub trait Error {
pub trait Error: Display {
/// A short description of the error; usually a static string.
fn description(&self) -> &str;
/// A detailed description of the error, usually including dynamic information.
fn detail(&self) -> Option<String> { None }
/// The lower-level cause of this error, if any.
fn cause(&self) -> Option<&Error> { None }
}
@ -112,26 +108,3 @@ impl<E> FromError<E> for E {
err
}
}
#[stable]
impl Error for Utf8Error {
fn description(&self) -> &str {
match *self {
Utf8Error::TooShort => "invalid utf-8: not enough bytes",
Utf8Error::InvalidByte(..) => "invalid utf-8: corrupt contents",
}
}
fn detail(&self) -> Option<String> { Some(self.to_string()) }
}
#[stable]
impl Error for FromUtf8Error {
fn description(&self) -> &str { "invalid utf-8" }
fn detail(&self) -> Option<String> { Some(self.to_string()) }
}
#[stable]
impl Error for FromUtf16Error {
fn description(&self) -> &str { "invalid utf-16" }
}

142
src/libcore/fmt/mod.rs
View File

@ -26,12 +26,15 @@ use ops::{Deref, FnOnce};
use result;
use slice::SliceExt;
use slice;
use str::{self, StrExt, Utf8Error};
use str::{self, StrExt};
pub use self::num::radix;
pub use self::num::Radix;
pub use self::num::RadixFmt;
#[cfg(stage0)] pub use self::Debug as Show;
#[cfg(stage0)] pub use self::Display as String;
mod num;
mod float;
pub mod rt;
@ -46,7 +49,7 @@ pub type Result = result::Result<(), Error>;
/// occurred. Any extra information must be arranged to be transmitted through
/// some other means.
#[unstable = "core and I/O reconciliation may alter this definition"]
#[derive(Copy)]
#[derive(Copy, Show)]
pub struct Error;
/// A collection of methods that are required to format a message into a stream.
@ -133,7 +136,7 @@ pub struct Argument<'a> {
impl<'a> Argument<'a> {
#[inline(never)]
fn show_uint(x: &uint, f: &mut Formatter) -> Result {
Show::fmt(x, f)
Display::fmt(x, f)
}
fn new<'b, T>(x: &'b T, f: fn(&T, &mut Formatter) -> Result) -> Argument<'b> {
@ -214,14 +217,15 @@ pub struct Arguments<'a> {
args: &'a [Argument<'a>],
}
impl<'a> Show for Arguments<'a> {
#[stable]
impl<'a> Debug for Arguments<'a> {
fn fmt(&self, fmt: &mut Formatter) -> Result {
String::fmt(self, fmt)
Display::fmt(self, fmt)
}
}
#[stable]
impl<'a> String for Arguments<'a> {
impl<'a> Display for Arguments<'a> {
fn fmt(&self, fmt: &mut Formatter) -> Result {
write(fmt.buf, *self)
}
@ -229,20 +233,49 @@ impl<'a> String for Arguments<'a> {
/// Format trait for the `:?` format. Useful for debugging, most all types
/// should implement this.
#[unstable = "I/O and core have yet to be reconciled"]
#[deprecated = "renamed to Debug"]
#[cfg(not(stage0))]
pub trait Show {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
/// Format trait for the `:?` format. Useful for debugging, most all types
/// should implement this.
#[unstable = "I/O and core have yet to be reconciled"]
pub trait Debug {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
#[cfg(not(stage0))]
impl<T: Show + ?Sized> Debug for T {
#[allow(deprecated)]
fn fmt(&self, f: &mut Formatter) -> Result { Show::fmt(self, f) }
}
/// When a value can be semantically expressed as a String, this trait may be
/// used. It corresponds to the default format, `{}`.
#[deprecated = "renamed to Display"]
#[cfg(not(stage0))]
pub trait String {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
/// When a value can be semantically expressed as a String, this trait may be
/// used. It corresponds to the default format, `{}`.
#[unstable = "I/O and core have yet to be reconciled"]
pub trait String {
pub trait Display {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
#[cfg(not(stage0))]
impl<T: String + ?Sized> Display for T {
#[allow(deprecated)]
fn fmt(&self, f: &mut Formatter) -> Result { String::fmt(self, f) }
}
/// Format trait for the `o` character
#[unstable = "I/O and core have yet to be reconciled"]
@ -583,9 +616,10 @@ impl<'a> Formatter<'a> {
pub fn precision(&self) -> Option<uint> { self.precision }
}
impl Show for Error {
#[stable]
impl Display for Error {
fn fmt(&self, f: &mut Formatter) -> Result {
String::fmt("an error occurred when formatting an argument", f)
Display::fmt("an error occurred when formatting an argument", f)
}
}
@ -611,9 +645,11 @@ pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
macro_rules! fmt_refs {
($($tr:ident),*) => {
$(
#[stable]
impl<'a, T: ?Sized + $tr> $tr for &'a T {
fn fmt(&self, f: &mut Formatter) -> Result { $tr::fmt(&**self, f) }
}
#[stable]
impl<'a, T: ?Sized + $tr> $tr for &'a mut T {
fn fmt(&self, f: &mut Formatter) -> Result { $tr::fmt(&**self, f) }
}
@ -621,22 +657,24 @@ macro_rules! fmt_refs {
}
}
fmt_refs! { Show, String, Octal, Binary, LowerHex, UpperHex, LowerExp, UpperExp }
fmt_refs! { Debug, Display, Octal, Binary, LowerHex, UpperHex, LowerExp, UpperExp }
impl Show for bool {
#[stable]
impl Debug for bool {
fn fmt(&self, f: &mut Formatter) -> Result {
String::fmt(self, f)
Display::fmt(self, f)
}
}
#[stable]
impl String for bool {
impl Display for bool {
fn fmt(&self, f: &mut Formatter) -> Result {
String::fmt(if *self { "true" } else { "false" }, f)
Display::fmt(if *self { "true" } else { "false" }, f)
}
}
impl Show for str {
#[stable]
impl Debug for str {
fn fmt(&self, f: &mut Formatter) -> Result {
try!(write!(f, "\""));
for c in self.chars().flat_map(|c| c.escape_default()) {
@ -647,13 +685,14 @@ impl Show for str {
}
#[stable]
impl String for str {
impl Display for str {
fn fmt(&self, f: &mut Formatter) -> Result {
f.pad(self)
}
}
impl Show for char {
#[stable]
impl Debug for char {
fn fmt(&self, f: &mut Formatter) -> Result {
use char::CharExt;
try!(write!(f, "'"));
@ -665,15 +704,16 @@ impl Show for char {
}
#[stable]
impl String for char {
impl Display for char {
fn fmt(&self, f: &mut Formatter) -> Result {
let mut utf8 = [0u8; 4];
let amt = self.encode_utf8(&mut utf8).unwrap_or(0);
let s: &str = unsafe { mem::transmute(&utf8[..amt]) };
String::fmt(s, f)
Display::fmt(s, f)
}
}
#[stable]
impl<T> Pointer for *const T {
fn fmt(&self, f: &mut Formatter) -> Result {
f.flags |= 1 << (rt::FlagAlternate as uint);
@ -683,18 +723,21 @@ impl<T> Pointer for *const T {
}
}
#[stable]
impl<T> Pointer for *mut T {
fn fmt(&self, f: &mut Formatter) -> Result {
Pointer::fmt(&(*self as *const T), f)
}
}
#[stable]
impl<'a, T> Pointer for &'a T {
fn fmt(&self, f: &mut Formatter) -> Result {
Pointer::fmt(&(*self as *const T), f)
}
}
#[stable]
impl<'a, T> Pointer for &'a mut T {
fn fmt(&self, f: &mut Formatter) -> Result {
Pointer::fmt(&(&**self as *const T), f)
@ -703,15 +746,15 @@ impl<'a, T> Pointer for &'a mut T {
macro_rules! floating { ($ty:ident) => {
impl Show for $ty {
#[stable]
impl Debug for $ty {
fn fmt(&self, fmt: &mut Formatter) -> Result {
try!(String::fmt(self, fmt));
fmt.write_str(stringify!($ty))
Display::fmt(self, fmt)
}
}
#[stable]
impl String for $ty {
impl Display for $ty {
fn fmt(&self, fmt: &mut Formatter) -> Result {
use num::Float;
@ -732,6 +775,7 @@ macro_rules! floating { ($ty:ident) => {
}
}
#[stable]
impl LowerExp for $ty {
fn fmt(&self, fmt: &mut Formatter) -> Result {
use num::Float;
@ -753,6 +797,7 @@ macro_rules! floating { ($ty:ident) => {
}
}
#[stable]
impl UpperExp for $ty {
fn fmt(&self, fmt: &mut Formatter) -> Result {
use num::Float;
@ -777,12 +822,14 @@ macro_rules! floating { ($ty:ident) => {
floating! { f32 }
floating! { f64 }
// Implementation of Show for various core types
// Implementation of Display/Debug for various core types
impl<T> Show for *const T {
#[stable]
impl<T> Debug for *const T {
fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
}
impl<T> Show for *mut T {
#[stable]
impl<T> Debug for *mut T {
fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
}
@ -793,7 +840,8 @@ macro_rules! peel {
macro_rules! tuple {
() => ();
( $($name:ident,)+ ) => (
impl<$($name:Show),*> Show for ($($name,)*) {
#[stable]
impl<$($name:Debug),*> Debug for ($($name,)*) {
#[allow(non_snake_case, unused_assignments)]
fn fmt(&self, f: &mut Formatter) -> Result {
try!(write!(f, "("));
@ -818,11 +866,13 @@ macro_rules! tuple {
tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
impl<'a> Show for &'a (any::Any+'a) {
#[stable]
impl<'a> Debug for &'a (any::Any+'a) {
fn fmt(&self, f: &mut Formatter) -> Result { f.pad("&Any") }
}
impl<T: Show> Show for [T] {
#[stable]
impl<T: Debug> Debug for [T] {
fn fmt(&self, f: &mut Formatter) -> Result {
if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
try!(write!(f, "["));
@ -843,20 +893,22 @@ impl<T: Show> Show for [T] {
}
}
impl Show for () {
#[stable]
impl Debug for () {
fn fmt(&self, f: &mut Formatter) -> Result {
f.pad("()")
}
}
impl<T: Copy + Show> Show for Cell<T> {
#[stable]
impl<T: Copy + Debug> Debug for Cell<T> {
fn fmt(&self, f: &mut Formatter) -> Result {
write!(f, "Cell {{ value: {:?} }}", self.get())
}
}
#[unstable]
impl<T: Show> Show for RefCell<T> {
#[stable]
impl<T: Debug> Debug for RefCell<T> {
fn fmt(&self, f: &mut Formatter) -> Result {
match self.try_borrow() {
Some(val) => write!(f, "RefCell {{ value: {:?} }}", val),
@ -865,29 +917,17 @@ impl<T: Show> Show for RefCell<T> {
}
}
impl<'b, T: Show> Show for Ref<'b, T> {
#[stable]
impl<'b, T: Debug> Debug for Ref<'b, T> {
fn fmt(&self, f: &mut Formatter) -> Result {
Show::fmt(&**self, f)
}
}
impl<'b, T: Show> Show for RefMut<'b, T> {
fn fmt(&self, f: &mut Formatter) -> Result {
Show::fmt(&*(self.deref()), f)
Debug::fmt(&**self, f)
}
}
#[stable]
impl String for Utf8Error {
impl<'b, T: Debug> Debug for RefMut<'b, T> {
fn fmt(&self, f: &mut Formatter) -> Result {
match *self {
Utf8Error::InvalidByte(n) => {
write!(f, "invalid utf-8: invalid byte at index {}", n)
}
Utf8Error::TooShort => {
write!(f, "invalid utf-8: byte slice too short")
}
}
Debug::fmt(&*(self.deref()), f)
}
}

20
src/libcore/fmt/num.rs
View File

@ -154,13 +154,14 @@ pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
macro_rules! radix_fmt {
($T:ty as $U:ty, $fmt:ident, $S:expr) => {
impl fmt::Show for RadixFmt<$T, Radix> {
#[stable]
impl fmt::Debug for RadixFmt<$T, Radix> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(fmt::String::fmt(self, f));
f.write_str($S)
fmt::Display::fmt(self, f)
}
}
impl fmt::String for RadixFmt<$T, Radix> {
#[stable]
impl fmt::Display for RadixFmt<$T, Radix> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self { RadixFmt(ref x, radix) => radix.$fmt(*x as $U, f) }
}
@ -169,6 +170,7 @@ macro_rules! radix_fmt {
}
macro_rules! int_base {
($Trait:ident for $T:ident as $U:ident -> $Radix:ident) => {
#[stable]
impl fmt::$Trait for $T {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
$Radix.fmt_int(*self as $U, f)
@ -179,10 +181,10 @@ macro_rules! int_base {
macro_rules! show {
($T:ident with $S:expr) => {
impl fmt::Show for $T {
#[stable]
impl fmt::Debug for $T {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(fmt::String::fmt(self, f));
f.write_str($S)
fmt::Display::fmt(self, f)
}
}
}
@ -192,7 +194,7 @@ macro_rules! integer {
integer! { $Int, $Uint, stringify!($Int), stringify!($Uint) }
};
($Int:ident, $Uint:ident, $SI:expr, $SU:expr) => {
int_base! { String for $Int as $Int -> Decimal }
int_base! { Display for $Int as $Int -> Decimal }
int_base! { Binary for $Int as $Uint -> Binary }
int_base! { Octal for $Int as $Uint -> Octal }
int_base! { LowerHex for $Int as $Uint -> LowerHex }
@ -200,7 +202,7 @@ macro_rules! integer {
radix_fmt! { $Int as $Int, fmt_int, $SI }
show! { $Int with $SI }
int_base! { String for $Uint as $Uint -> Decimal }
int_base! { Display for $Uint as $Uint -> Decimal }
int_base! { Binary for $Uint as $Uint -> Binary }
int_base! { Octal for $Uint as $Uint -> Octal }
int_base! { LowerHex for $Uint as $Uint -> LowerHex }

1
src/libcore/lib.rs
View File

@ -136,6 +136,7 @@ pub mod slice;
pub mod str;
pub mod hash;
pub mod fmt;
pub mod error;
// note: does not need to be public
mod tuple;

18
src/libcore/ops.rs
View File

@ -885,10 +885,10 @@ pub trait IndexMut<Index: ?Sized> {
#[unstable = "API still in development"]
pub struct FullRange;
#[unstable = "API still in development"]
impl fmt::Show for FullRange {
#[stable]
impl fmt::Debug for FullRange {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt("..", fmt)
fmt::Debug::fmt("..", fmt)
}
}
@ -944,8 +944,8 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
#[unstable = "API still in development"]
impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
#[unstable = "API still in development"]
impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
#[stable]
impl<Idx: fmt::Debug> fmt::Debug for Range<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{:?}..{:?}", self.start, self.end)
}
@ -973,8 +973,8 @@ impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
}
}
#[unstable = "API still in development"]
impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
#[stable]
impl<Idx: fmt::Debug> fmt::Debug for RangeFrom<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{:?}..", self.start)
}
@ -989,8 +989,8 @@ pub struct RangeTo<Idx> {
pub end: Idx,
}
#[unstable = "API still in development"]
impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> {
#[stable]
impl<Idx: fmt::Debug> fmt::Debug for RangeTo<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "..{:?}", self.end)
}

10
src/libcore/result.rs
View File

@ -229,7 +229,7 @@
use self::Result::{Ok, Err};
use clone::Clone;
use fmt::Show;
use fmt::Display;
use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator, ExactSizeIterator};
use ops::{FnMut, FnOnce};
use option::Option::{self, None, Some};
@ -714,7 +714,7 @@ impl<T, E> Result<T, E> {
}
#[stable]
impl<T, E: Show> Result<T, E> {
impl<T, E: Display> Result<T, E> {
/// Unwraps a result, yielding the content of an `Ok`.
///
/// # Panics
@ -739,13 +739,13 @@ impl<T, E: Show> Result<T, E> {
match self {
Ok(t) => t,
Err(e) =>
panic!("called `Result::unwrap()` on an `Err` value: {:?}", e)
panic!("called `Result::unwrap()` on an `Err` value: {}", e)
}
}
}
#[stable]
impl<T: Show, E> Result<T, E> {
impl<T: Display, E> Result<T, E> {
/// Unwraps a result, yielding the content of an `Err`.
///
/// # Panics
@ -769,7 +769,7 @@ impl<T: Show, E> Result<T, E> {
pub fn unwrap_err(self) -> E {
match self {
Ok(t) =>
panic!("called `Result::unwrap_err()` on an `Ok` value: {:?}", t),
panic!("called `Result::unwrap_err()` on an `Ok` value: {}", t),
Err(e) => e
}
}

28
src/libcore/str/mod.rs
View File

@ -20,8 +20,10 @@ use self::Searcher::{Naive, TwoWay, TwoWayLong};
use cmp::{self, Eq};
use default::Default;
use iter::range;
use error::Error;
use fmt;
use iter::ExactSizeIterator;
use iter::range;
use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator};
use marker::Sized;
use mem;
@ -242,6 +244,30 @@ impl<'a> CharEq for &'a [char] {
}
}
#[stable]
impl Error for Utf8Error {
fn description(&self) -> &str {
match *self {
Utf8Error::TooShort => "invalid utf-8: not enough bytes",
Utf8Error::InvalidByte(..) => "invalid utf-8: corrupt contents",
}
}
}
#[stable]
impl fmt::Display for Utf8Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Utf8Error::InvalidByte(n) => {
write!(f, "invalid utf-8: invalid byte at index {}", n)
}
Utf8Error::TooShort => {
write!(f, "invalid utf-8: byte slice too short")
}
}
}
}
/*
Section: Iterators
*/

2
src/libcoretest/finally.rs
View File

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![allow(deprecated)]
use core::finally::{try_finally, Finally};
use std::thread::Thread;

24
src/libcoretest/fmt/num.rs
View File

@ -26,11 +26,11 @@ fn test_format_int() {
assert!(format!("{}", -1i16) == "-1");
assert!(format!("{}", -1i32) == "-1");
assert!(format!("{}", -1i64) == "-1");
assert!(format!("{:?}", 1i) == "1i");
assert!(format!("{:?}", 1i8) == "1i8");
assert!(format!("{:?}", 1i16) == "1i16");
assert!(format!("{:?}", 1i32) == "1i32");
assert!(format!("{:?}", 1i64) == "1i64");
assert!(format!("{:?}", 1i) == "1");
assert!(format!("{:?}", 1i8) == "1");
assert!(format!("{:?}", 1i16) == "1");
assert!(format!("{:?}", 1i32) == "1");
assert!(format!("{:?}", 1i64) == "1");
assert!(format!("{:b}", 1i) == "1");
assert!(format!("{:b}", 1i8) == "1");
assert!(format!("{:b}", 1i16) == "1");
@ -57,11 +57,11 @@ fn test_format_int() {
assert!(format!("{}", 1u16) == "1");
assert!(format!("{}", 1u32) == "1");
assert!(format!("{}", 1u64) == "1");
assert!(format!("{:?}", 1u) == "1u");
assert!(format!("{:?}", 1u8) == "1u8");
assert!(format!("{:?}", 1u16) == "1u16");
assert!(format!("{:?}", 1u32) == "1u32");
assert!(format!("{:?}", 1u64) == "1u64");
assert!(format!("{:?}", 1u) == "1");
assert!(format!("{:?}", 1u8) == "1");
assert!(format!("{:?}", 1u16) == "1");
assert!(format!("{:?}", 1u32) == "1");
assert!(format!("{:?}", 1u64) == "1");
assert!(format!("{:b}", 1u) == "1");
assert!(format!("{:b}", 1u8) == "1");
assert!(format!("{:b}", 1u16) == "1");
@ -94,14 +94,14 @@ fn test_format_int() {
#[test]
fn test_format_int_zero() {
assert!(format!("{}", 0i) == "0");
assert!(format!("{:?}", 0i) == "0i");
assert!(format!("{:?}", 0i) == "0");
assert!(format!("{:b}", 0i) == "0");
assert!(format!("{:o}", 0i) == "0");
assert!(format!("{:x}", 0i) == "0");
assert!(format!("{:X}", 0i) == "0");
assert!(format!("{}", 0u) == "0");
assert!(format!("{:?}", 0u) == "0u");
assert!(format!("{:?}", 0u) == "0");
assert!(format!("{:b}", 0u) == "0");
assert!(format!("{:o}", 0u) == "0");
assert!(format!("{:x}", 0u) == "0");

4
src/libcoretest/num/mod.rs
View File

@ -9,7 +9,7 @@
// except according to those terms.
use core::cmp::PartialEq;
use core::fmt::Show;
use core::fmt::Debug;
use core::num::{NumCast, cast};
use core::ops::{Add, Sub, Mul, Div, Rem};
use core::marker::Copy;
@ -37,7 +37,7 @@ pub fn test_num<T>(ten: T, two: T) where
T: PartialEq + NumCast
+ Add<Output=T> + Sub<Output=T>
+ Mul<Output=T> + Div<Output=T>
+ Rem<Output=T> + Show
+ Rem<Output=T> + Debug
+ Copy
{
assert_eq!(ten.add(two), cast(12i).unwrap());

6
src/libcoretest/result.rs
View File

@ -14,11 +14,11 @@ pub fn op2() -> Result<int, &'static str> { Err("sadface") }
#[test]
pub fn test_and() {
assert_eq!(op1().and(Ok(667i)).unwrap(), 667);
assert_eq!(op1().and(Err::<(), &'static str>("bad")).unwrap_err(),
assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(),
"bad");
assert_eq!(op2().and(Ok(667i)).unwrap_err(), "sadface");
assert_eq!(op2().and(Err::<(),&'static str>("bad")).unwrap_err(),
assert_eq!(op2().and(Err::<i32,&'static str>("bad")).unwrap_err(),
"sadface");
}
@ -94,7 +94,7 @@ pub fn test_fmt_default() {
let err: Result<int, &'static str> = Err("Err");
let s = format!("{:?}", ok);
assert_eq!(s, "Ok(100i)");
assert_eq!(s, "Ok(100)");
let s = format!("{:?}", err);
assert_eq!(s, "Err(\"Err\")");
}

6
src/libcoretest/tuple.rs
View File

@ -60,9 +60,9 @@ fn test_tuple_cmp() {
#[test]
fn test_show() {
let s = format!("{:?}", (1i,));
assert_eq!(s, "(1i,)");
assert_eq!(s, "(1,)");
let s = format!("{:?}", (1i, true));
assert_eq!(s, "(1i, true)");
assert_eq!(s, "(1, true)");
let s = format!("{:?}", (1i, "hi", true));
assert_eq!(s, "(1i, \"hi\", true)");
assert_eq!(s, "(1, \"hi\", true)");
}

2
src/libgetopts/lib.rs
View File

@ -544,7 +544,7 @@ impl Fail {
}
}
impl fmt::String for Fail {
impl fmt::Display for Fail {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ArgumentMissing(ref nm) => {

16
src/libgraphviz/lib.rs
View File

@ -358,19 +358,19 @@ impl<'a> Id<'a> {
///
/// Passing an invalid string (containing spaces, brackets,
/// quotes, ...) will return an empty `Err` value.
pub fn new<Name: IntoCow<'a, String, str>>(name: Name) -> Result<Id<'a>, ()> {
pub fn new<Name: IntoCow<'a, String, str>>(name: Name) -> Option<Id<'a>> {
let name = name.into_cow();
{
let mut chars = name.chars();
match chars.next() {
Some(c) if is_letter_or_underscore(c) => { ; },
_ => return Err(())
_ => return None
}
if !chars.all(is_constituent) {
return Err(());
return None
}
}
return Ok(Id{ name: name });
return Some(Id{ name: name });
fn is_letter_or_underscore(c: char) -> bool {
in_range('a', c, 'z') || in_range('A', c, 'Z') || c == '_'
@ -874,8 +874,8 @@ r#"digraph syntax_tree {
fn simple_id_construction() {
let id1 = Id::new("hello");
match id1 {
Ok(_) => {;},
Err(_) => panic!("'hello' is not a valid value for id anymore")
Some(_) => {;},
None => panic!("'hello' is not a valid value for id anymore")
}
}
@ -883,8 +883,8 @@ r#"digraph syntax_tree {
fn badly_formatted_id() {
let id2 = Id::new("Weird { struct : ure } !!!");
match id2 {
Ok(_) => panic!("graphviz id suddenly allows spaces, brackets and stuff"),
Err(_) => {;}
Some(_) => panic!("graphviz id suddenly allows spaces, brackets and stuff"),
None => {;}
}
}
}

2
src/libgraphviz/maybe_owned_vec.rs
View File

@ -124,7 +124,7 @@ impl<'a,T> FromIterator<T> for MaybeOwnedVector<'a,T> {
}
}
impl<'a,T:fmt::Show> fmt::Show for MaybeOwnedVector<'a,T> {
impl<'a,T:fmt::Debug> fmt::Debug for MaybeOwnedVector<'a,T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.as_slice().fmt(f)
}

14
src/liblog/lib.rs
View File

@ -239,21 +239,15 @@ struct DefaultLogger {
}
/// Wraps the log level with fmt implementations.
#[derive(Copy, PartialEq, PartialOrd)]
#[derive(Copy, PartialEq, PartialOrd, Show)]
pub struct LogLevel(pub u32);
impl fmt::Show for LogLevel {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, fmt)
}
}
impl fmt::String for LogLevel {
impl fmt::Display for LogLevel {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let LogLevel(level) = *self;
match LOG_LEVEL_NAMES.get(level as uint - 1) {
Some(ref name) => fmt::String::fmt(name, fmt),
None => fmt::String::fmt(&level, fmt)
Some(ref name) => fmt::Display::fmt(name, fmt),
None => fmt::Display::fmt(&level, fmt)
}
}
}

8
src/librbml/lib.rs
View File

@ -38,6 +38,7 @@ pub use self::EbmlEncoderTag::*;
pub use self::Error::*;
use std::str;
use std::fmt;
pub mod io;
@ -113,6 +114,13 @@ pub enum Error {
IoError(std::io::IoError),
ApplicationError(String)
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// FIXME: this should be a more useful display form
fmt::Debug::fmt(self, f)
}
}
// --------------------------------------
pub mod reader {

3
src/libregex/parse.rs
View File

@ -30,6 +30,7 @@ static MAX_REPEAT: uint = 1000;
///
/// (Once an expression is compiled, it is not possible to produce an error
/// via searching, splitting or replacing.)
#[derive(Show)]
pub struct Error {
/// The *approximate* character index of where the error occurred.
pub pos: uint,
@ -37,7 +38,7 @@ pub struct Error {
pub msg: String,
}
impl fmt::Show for Error {
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Regex syntax error near position {}: {:?}",
self.pos, self.msg)

4
src/libregex/re.rs
View File

@ -90,10 +90,10 @@ impl Clone for ExNative {
}
}
impl fmt::String for Regex {
impl fmt::Display for Regex {
/// Shows the original regular expression.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self.as_str(), f)
fmt::Display::fmt(self.as_str(), f)
}
}

2
src/librustc/middle/check_match.rs
View File

@ -57,7 +57,7 @@ struct Matrix<'a>(Vec<Vec<&'a Pat>>);
/// ++++++++++++++++++++++++++
/// + _ + [_, _, ..tail] +
/// ++++++++++++++++++++++++++
impl<'a> fmt::Show for Matrix<'a> {
impl<'a> fmt::Debug for Matrix<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "\n"));

8
src/librustc/middle/graph.rs
View File

@ -32,7 +32,7 @@
#![allow(dead_code)] // still WIP
use std::fmt::{Formatter, Error, Show};
use std::fmt::{Formatter, Error, Debug};
use std::uint;
use std::collections::BitvSet;
@ -53,7 +53,7 @@ pub struct Edge<E> {
pub data: E,
}
impl<E: Show> Show for Edge<E> {
impl<E: Debug> Debug for Edge<E> {
fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
write!(f, "Edge {{ next_edge: [{:?}, {:?}], source: {:?}, target: {:?}, data: {:?} }}",
self.next_edge[0], self.next_edge[1], self.source,
@ -353,7 +353,7 @@ impl<E> Edge<E> {
#[cfg(test)]
mod test {
use middle::graph::*;
use std::fmt::Show;
use std::fmt::Debug;
type TestNode = Node<&'static str>;
type TestEdge = Edge<&'static str>;
@ -408,7 +408,7 @@ mod test {
});
}
fn test_adjacent_edges<N:PartialEq+Show,E:PartialEq+Show>(graph: &Graph<N,E>,
fn test_adjacent_edges<N:PartialEq+Debug,E:PartialEq+Debug>(graph: &Graph<N,E>,
start_index: NodeIndex,
start_data: N,
expected_incoming: &[(E,N)],

4
src/librustc/middle/infer/unify.rs
View File

@ -17,7 +17,7 @@ use middle::ty::{self, Ty};
use middle::infer::{uok, ures};
use middle::infer::InferCtxt;
use std::cell::RefCell;
use std::fmt::Show;
use std::fmt::Debug;
use syntax::ast;
use util::ppaux::Repr;
use util::snapshot_vec as sv;
@ -32,7 +32,7 @@ use util::snapshot_vec as sv;
/// (possibly not yet known) sort of integer.
///
/// Implementations of this trait are at the end of this file.
pub trait UnifyKey<'tcx, V> : Clone + Show + PartialEq + Repr<'tcx> {
pub trait UnifyKey<'tcx, V> : Clone + Debug + PartialEq + Repr<'tcx> {
fn index(&self) -> uint;
fn from_index(u: uint) -> Self;

4
src/librustc/middle/liveness.rs
View File

@ -198,13 +198,13 @@ pub fn check_crate(tcx: &ty::ctxt) {
tcx.sess.abort_if_errors();
}
impl fmt::Show for LiveNode {
impl fmt::Debug for LiveNode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ln({})", self.get())
}
}
impl fmt::Show for Variable {
impl fmt::Debug for Variable {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "v({})", self.get())
}

2
src/librustc/middle/resolve_lifetime.rs
View File

@ -602,7 +602,7 @@ fn early_bound_lifetime_names(generics: &ast::Generics) -> Vec<ast::Name> {
}
}
impl<'a> fmt::Show for ScopeChain<'a> {
impl<'a> fmt::Debug for ScopeChain<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self {
EarlyScope(space, defs, _) => write!(fmt, "EarlyScope({:?}, {:?})", space, defs),

2
src/librustc/middle/subst.rs
View File

@ -238,7 +238,7 @@ pub struct SeparateVecsPerParamSpace<T> {
pub fns: Vec<T>,
}
impl<T:fmt::Show> fmt::Show for VecPerParamSpace<T> {
impl<T: fmt::Debug> fmt::Debug for VecPerParamSpace<T> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
try!(write!(fmt, "VecPerParamSpace {{"));
for space in ParamSpace::all().iter() {

4
src/librustc/middle/traits/error_reporting.rs
View File

@ -200,7 +200,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
ty::Predicate::Equate(ref predicate) => {
let predicate = infcx.resolve_type_vars_if_possible(predicate);
let err = infcx.equality_predicate(obligation.cause.span,
&predicate).unwrap_err();
&predicate).err().unwrap();
infcx.tcx.sess.span_err(
obligation.cause.span,
format!(
@ -212,7 +212,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
ty::Predicate::RegionOutlives(ref predicate) => {
let predicate = infcx.resolve_type_vars_if_possible(predicate);
let err = infcx.region_outlives_predicate(obligation.cause.span,
&predicate).unwrap_err();
&predicate).err().unwrap();
infcx.tcx.sess.span_err(
obligation.cause.span,
format!(

8
src/librustc/middle/traits/util.rs
View File

@ -236,13 +236,13 @@ pub fn fresh_substs_for_impl<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
infcx.fresh_substs_for_generics(span, &impl_generics)
}
impl<'tcx, N> fmt::Show for VtableImplData<'tcx, N> {
impl<'tcx, N> fmt::Debug for VtableImplData<'tcx, N> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "VtableImpl({:?})", self.impl_def_id)
}
}
impl<'tcx> fmt::Show for super::VtableObjectData<'tcx> {
impl<'tcx> fmt::Debug for super::VtableObjectData<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "VtableObject(...)")
}
@ -449,7 +449,7 @@ impl<'tcx> Repr<'tcx> for super::FulfillmentErrorCode<'tcx> {
}
}
impl<'tcx> fmt::Show for super::FulfillmentErrorCode<'tcx> {
impl<'tcx> fmt::Debug for super::FulfillmentErrorCode<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
super::CodeSelectionError(ref e) => write!(f, "{:?}", e),
@ -465,7 +465,7 @@ impl<'tcx> Repr<'tcx> for super::MismatchedProjectionTypes<'tcx> {
}
}
impl<'tcx> fmt::Show for super::MismatchedProjectionTypes<'tcx> {
impl<'tcx> fmt::Debug for super::MismatchedProjectionTypes<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "MismatchedProjectionTypes(..)")
}

18
src/librustc/middle/ty.rs
View File

@ -934,7 +934,7 @@ pub struct TyS<'tcx> {
region_depth: u32,
}
impl fmt::Show for TypeFlags {
impl fmt::Debug for TypeFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.bits)
}
@ -1703,37 +1703,37 @@ impl cmp::PartialEq for InferRegion {
}
}
impl fmt::Show for TyVid {
impl fmt::Debug for TyVid {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
write!(f, "_#{}t", self.index)
}
}
impl fmt::Show for IntVid {
impl fmt::Debug for IntVid {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "_#{}i", self.index)
}
}
impl fmt::Show for FloatVid {
impl fmt::Debug for FloatVid {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "_#{}f", self.index)
}
}
impl fmt::Show for RegionVid {
impl fmt::Debug for RegionVid {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "'_#{}r", self.index)
}
}
impl<'tcx> fmt::Show for FnSig<'tcx> {
impl<'tcx> fmt::Debug for FnSig<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({:?}; variadic: {})->{:?}", self.inputs, self.variadic, self.output)
}
}
impl fmt::Show for InferTy {
impl fmt::Debug for InferTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TyVar(ref v) => v.fmt(f),
@ -1745,7 +1745,7 @@ impl fmt::Show for InferTy {
}
}
impl fmt::Show for IntVarValue {
impl fmt::Debug for IntVarValue {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
IntType(ref v) => v.fmt(f),
@ -3319,7 +3319,7 @@ impl ops::Sub for TypeContents {
}
}
impl fmt::Show for TypeContents {
impl fmt::Debug for TypeContents {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "TypeContents({:b})", self.bits)
}

4
src/librustc/session/config.rs
View File

@ -249,7 +249,7 @@ pub enum EntryFnType {
EntryNone,
}
#[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash)]
#[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash, Show)]
pub enum CrateType {
CrateTypeExecutable,
CrateTypeDylib,
@ -1159,7 +1159,7 @@ pub fn parse_crate_types_from_list(list_list: Vec<String>) -> Result<Vec<CrateTy
return Ok(crate_types);
}
impl fmt::Show for CrateType {
impl fmt::Display for CrateType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CrateTypeExecutable => "bin".fmt(f),

4
src/librustc/util/common.rs
View File

@ -12,7 +12,7 @@
use std::cell::{RefCell, Cell};
use std::collections::HashMap;
use std::fmt::Show;
use std::fmt::Debug;
use std::hash::{Hash, Hasher};
use std::iter::repeat;
use std::time::Duration;
@ -58,7 +58,7 @@ pub fn time<T, U, F>(do_it: bool, what: &str, u: U, f: F) -> T where
}
pub fn indent<R, F>(op: F) -> R where
R: Show,
R: Debug,
F: FnOnce() -> R,
{
// Use in conjunction with the log post-processor like `src/etc/indenter`

6
src/librustc_back/archive.rs
View File

@ -59,7 +59,7 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option<String>,
let mut cmd = Command::new(ar);
cmd.arg(args).args(paths);
debug!("{}", cmd);
debug!("{:?}", cmd);
match cwd {
Some(p) => {
@ -73,9 +73,7 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option<String>,
Ok(prog) => {
let o = prog.wait_with_output().unwrap();
if !o.status.success() {
handler.err(&format!("{} failed with: {}",
cmd,
o.status)[]);
handler.err(&format!("{:?} failed with: {}", cmd, o.status)[]);
handler.note(&format!("stdout ---\n{}",
str::from_utf8(&o.output[]).unwrap())[]);
handler.note(&format!("stderr ---\n{}",

10
src/librustc_back/svh.rs
View File

@ -52,7 +52,7 @@ use std::iter::range_step;
use syntax::ast;
use syntax::visit;
#[derive(Clone, PartialEq)]
#[derive(Clone, PartialEq, Show)]
pub struct Svh {
hash: String,
}
@ -117,13 +117,7 @@ impl Svh {
}
}
impl fmt::Show for Svh {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Svh {{ {} }}", self.as_str())
}
}
impl fmt::String for Svh {
impl fmt::Display for Svh {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.pad(self.as_str())
}

2
src/librustc_borrowck/borrowck/gather_loans/mod.rs
View File

@ -491,7 +491,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for StaticInitializerCtxt<'a, 'tcx> {
if let ast::ExprAddrOf(mutbl, ref base) = ex.node {
let param_env = ty::empty_parameter_environment(self.bccx.tcx);
let mc = mc::MemCategorizationContext::new(&param_env);
let base_cmt = mc.cat_expr(&**base).unwrap();
let base_cmt = mc.cat_expr(&**base).ok().unwrap();
let borrow_kind = ty::BorrowKind::from_mutbl(mutbl);
// Check that we don't allow borrows of unsafe static items.
if check_aliasability(self.bccx, ex.span, euv::AddrOf,

2
src/librustc_resolve/lib.rs
View File

@ -536,7 +536,7 @@ impl Module {
}
}
impl fmt::Show for Module {
impl fmt::Debug for Module {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:?}, kind: {:?}, {}",
self.def_id,

6
src/librustc_trans/back/link.rs
View File

@ -779,14 +779,14 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool,
}
if sess.opts.debugging_opts.print_link_args {
println!("{}", &cmd);
println!("{:?}", &cmd);
}
// May have not found libraries in the right formats.
sess.abort_if_errors();
// Invoke the system linker
debug!("{}", &cmd);
debug!("{:?}", &cmd);
let prog = time(sess.time_passes(), "running linker", (), |()| cmd.output());
match prog {
Ok(prog) => {
@ -794,7 +794,7 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool,
sess.err(&format!("linking with `{}` failed: {}",
pname,
prog.status)[]);
sess.note(&format!("{}", &cmd)[]);
sess.note(&format!("{:?}", &cmd)[]);
let mut output = prog.error.clone();
output.push_all(&prog.output[]);
sess.note(str::from_utf8(&output[]).unwrap());

8
src/librustc_trans/back/write.rs
View File

@ -716,7 +716,7 @@ pub fn run_passes(sess: &Session,
cmd.args(&sess.target.target.options.post_link_args[]);
if sess.opts.debugging_opts.print_link_args {
println!("{}", &cmd);
println!("{:?}", &cmd);
}
cmd.stdin(::std::io::process::Ignored)
@ -725,7 +725,7 @@ pub fn run_passes(sess: &Session,
match cmd.status() {
Ok(status) => {
if !status.success() {
sess.err(&format!("linking of {} with `{}` failed",
sess.err(&format!("linking of {} with `{:?}` failed",
output_path.display(), cmd)[]);
sess.abort_if_errors();
}
@ -953,7 +953,7 @@ pub fn run_assembler(sess: &Session, outputs: &OutputFilenames) {
cmd.arg("-c").arg("-o").arg(outputs.path(config::OutputTypeObject))
.arg(outputs.temp_path(config::OutputTypeAssembly));
debug!("{}", &cmd);
debug!("{:?}", &cmd);
match cmd.output() {
Ok(prog) => {
@ -961,7 +961,7 @@ pub fn run_assembler(sess: &Session, outputs: &OutputFilenames) {
sess.err(&format!("linking with `{}` failed: {}",
pname,
prog.status)[]);
sess.note(&format!("{}", &cmd)[]);
sess.note(&format!("{:?}", &cmd)[]);
let mut note = prog.error.clone();
note.push_all(&prog.output[]);
sess.note(str::from_utf8(&note[]).unwrap());

2
src/librustc_trans/trans/cleanup.rs
View File

@ -65,7 +65,7 @@ pub enum CleanupScopeKind<'blk, 'tcx: 'blk> {
LoopScopeKind(ast::NodeId, [Block<'blk, 'tcx>; EXIT_MAX])
}
impl<'blk, 'tcx: 'blk> fmt::Show for CleanupScopeKind<'blk, 'tcx> {
impl<'blk, 'tcx: 'blk> fmt::Debug for CleanupScopeKind<'blk, 'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CustomScopeKind => write!(f, "CustomScopeKind"),

4
src/librustc_trans/trans/datum.rs
View File

@ -481,7 +481,7 @@ impl<'tcx> Datum<'tcx, Lvalue> {
}
/// Generic methods applicable to any sort of datum.
impl<'tcx, K: KindOps + fmt::Show> Datum<'tcx, K> {
impl<'tcx, K: KindOps + fmt::Debug> Datum<'tcx, K> {
pub fn new(val: ValueRef, ty: Ty<'tcx>, kind: K) -> Datum<'tcx, K> {
Datum { val: val, ty: ty, kind: kind }
}
@ -591,7 +591,7 @@ impl<'blk, 'tcx, K> DatumBlock<'blk, 'tcx, K> {
}
}
impl<'blk, 'tcx, K: KindOps + fmt::Show> DatumBlock<'blk, 'tcx, K> {
impl<'blk, 'tcx, K: KindOps + fmt::Debug> DatumBlock<'blk, 'tcx, K> {
pub fn to_expr_datumblock(self) -> DatumBlock<'blk, 'tcx, Expr> {
DatumBlock::new(self.bcx, self.datum.to_expr_datum())
}

2
src/librustc_typeck/variance.rs
View File

@ -240,7 +240,7 @@ enum VarianceTerm<'a> {
InferredTerm(InferredIndex),
}
impl<'a> fmt::Show for VarianceTerm<'a> {
impl<'a> fmt::Debug for VarianceTerm<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConstantTerm(c1) => write!(f, "{:?}", c1),

2
src/librustdoc/html/escape.rs
View File

@ -19,7 +19,7 @@ use std::fmt;
/// string when passed to a format string.
pub struct Escape<'a>(pub &'a str);
impl<'a> fmt::String for Escape<'a> {
impl<'a> fmt::Display for Escape<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
// Because the internet is always right, turns out there's not that many
// characters to escape: http://stackoverflow.com/questions/7381974

52
src/librustdoc/html/format.rs
View File

@ -66,7 +66,7 @@ impl UnsafetySpace {
}
}
impl<'a, T: fmt::String> fmt::String for CommaSep<'a, T> {
impl<'a, T: fmt::Display> fmt::Display for CommaSep<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (i, item) in self.0.iter().enumerate() {
if i != 0 { try!(write!(f, ", ")); }
@ -76,7 +76,7 @@ impl<'a, T: fmt::String> fmt::String for CommaSep<'a, T> {
}
}
impl<'a> fmt::String for TyParamBounds<'a> {
impl<'a> fmt::Display for TyParamBounds<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let &TyParamBounds(bounds) = self;
for (i, bound) in bounds.iter().enumerate() {
@ -89,7 +89,7 @@ impl<'a> fmt::String for TyParamBounds<'a> {
}
}
impl fmt::String for clean::Generics {
impl fmt::Display for clean::Generics {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.lifetimes.len() == 0 && self.type_params.len() == 0 { return Ok(()) }
try!(f.write_str("&lt;"));
@ -126,7 +126,7 @@ impl fmt::String for clean::Generics {
}
}
impl<'a> fmt::String for WhereClause<'a> {
impl<'a> fmt::Display for WhereClause<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let &WhereClause(gens) = self;
if gens.where_predicates.len() == 0 {
@ -163,14 +163,14 @@ impl<'a> fmt::String for WhereClause<'a> {
}
}
impl fmt::String for clean::Lifetime {
impl fmt::Display for clean::Lifetime {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(f.write_str(self.get_ref()));
Ok(())
}
}
impl fmt::String for clean::PolyTrait {
impl fmt::Display for clean::PolyTrait {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.lifetimes.len() > 0 {
try!(f.write_str("for&lt;"));
@ -186,7 +186,7 @@ impl fmt::String for clean::PolyTrait {
}
}
impl fmt::String for clean::TyParamBound {
impl fmt::Display for clean::TyParamBound {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::RegionBound(ref lt) => {
@ -203,7 +203,7 @@ impl fmt::String for clean::TyParamBound {
}
}
impl fmt::String for clean::PathParameters {
impl fmt::Display for clean::PathParameters {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::PathParameters::AngleBracketed {
@ -257,14 +257,14 @@ impl fmt::String for clean::PathParameters {
}
}
impl fmt::String for clean::PathSegment {
impl fmt::Display for clean::PathSegment {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(f.write_str(self.name.as_slice()));
write!(f, "{}", self.params)
}
}
impl fmt::String for clean::Path {
impl fmt::Display for clean::Path {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.global {
try!(f.write_str("::"))
@ -450,7 +450,7 @@ fn tybounds(w: &mut fmt::Formatter,
}
}
impl fmt::String for clean::Type {
impl fmt::Display for clean::Type {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::TyParamBinder(id) => {
@ -539,7 +539,7 @@ impl fmt::String for clean::Type {
}
}
impl fmt::String for clean::Arguments {
impl fmt::Display for clean::Arguments {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (i, input) in self.values.iter().enumerate() {
if i > 0 { try!(write!(f, ", ")); }
@ -552,7 +552,7 @@ impl fmt::String for clean::Arguments {
}
}
impl fmt::String for clean::FunctionRetTy {
impl fmt::Display for clean::FunctionRetTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::Return(clean::Tuple(ref tys)) if tys.is_empty() => Ok(()),
@ -563,13 +563,13 @@ impl fmt::String for clean::FunctionRetTy {
}
}
impl fmt::String for clean::FnDecl {
impl fmt::Display for clean::FnDecl {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({args}){arrow}", args = self.inputs, arrow = self.output)
}
}
impl<'a> fmt::String for Method<'a> {
impl<'a> fmt::Display for Method<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Method(selfty, d) = *self;
let mut args = String::new();
@ -599,7 +599,7 @@ impl<'a> fmt::String for Method<'a> {
}
}
impl fmt::String for VisSpace {
impl fmt::Display for VisSpace {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.get() {
Some(ast::Public) => write!(f, "pub "),
@ -608,7 +608,7 @@ impl fmt::String for VisSpace {
}
}
impl fmt::String for UnsafetySpace {
impl fmt::Display for UnsafetySpace {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.get() {
ast::Unsafety::Unsafe => write!(f, "unsafe "),
@ -617,7 +617,7 @@ impl fmt::String for UnsafetySpace {
}
}
impl fmt::String for clean::ViewPath {
impl fmt::Display for clean::ViewPath {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::SimpleImport(ref name, ref src) => {
@ -644,7 +644,7 @@ impl fmt::String for clean::ViewPath {
}
}
impl fmt::String for clean::ImportSource {
impl fmt::Display for clean::ImportSource {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.did {
Some(did) => resolved_path(f, did, &self.path, true),
@ -661,7 +661,7 @@ impl fmt::String for clean::ImportSource {
}
}
impl fmt::String for clean::ViewListIdent {
impl fmt::Display for clean::ViewListIdent {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.source {
Some(did) => {
@ -683,13 +683,13 @@ impl fmt::String for clean::ViewListIdent {
}
}
impl fmt::String for clean::TypeBinding {
impl fmt::Display for clean::TypeBinding {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}={}", self.name, self.ty)
}
}
impl fmt::String for MutableSpace {
impl fmt::Display for MutableSpace {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MutableSpace(clean::Immutable) => Ok(()),
@ -698,7 +698,7 @@ impl fmt::String for MutableSpace {
}
}
impl fmt::String for RawMutableSpace {
impl fmt::Display for RawMutableSpace {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RawMutableSpace(clean::Immutable) => write!(f, "const "),
@ -707,7 +707,7 @@ impl fmt::String for RawMutableSpace {
}
}
impl<'a> fmt::String for Stability<'a> {
impl<'a> fmt::Display for Stability<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Stability(stab) = *self;
match *stab {
@ -721,7 +721,7 @@ impl<'a> fmt::String for Stability<'a> {
}
}
impl<'a> fmt::String for ConciseStability<'a> {
impl<'a> fmt::Display for ConciseStability<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let ConciseStability(stab) = *self;
match *stab {
@ -738,7 +738,7 @@ impl<'a> fmt::String for ConciseStability<'a> {
}
}
impl fmt::String for ModuleSummary {
impl fmt::Display for ModuleSummary {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt_inner<'a>(f: &mut fmt::Formatter,
context: &mut Vec<&'a str>,

2
src/librustdoc/html/item_type.rs
View File

@ -103,7 +103,7 @@ impl ItemType {
}
}
impl fmt::String for ItemType {
impl fmt::Display for ItemType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.to_static_str().fmt(f)
}

2
src/librustdoc/html/layout.rs
View File

@ -30,7 +30,7 @@ pub struct Page<'a> {
pub keywords: &'a str
}
pub fn render<T: fmt::String, S: fmt::String>(
pub fn render<T: fmt::Display, S: fmt::Display>(
dst: &mut io::Writer, layout: &Layout, page: &Page, sidebar: &S, t: &T)
-> io::IoResult<()>
{

4
src/librustdoc/html/markdown.rs
View File

@ -426,7 +426,7 @@ pub fn reset_headers() {
USED_HEADER_MAP.with(|s| s.borrow_mut().clear());
}
impl<'a> fmt::String for Markdown<'a> {
impl<'a> fmt::Display for Markdown<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let Markdown(md) = *self;
// This is actually common enough to special-case
@ -435,7 +435,7 @@ impl<'a> fmt::String for Markdown<'a> {
}
}
impl<'a> fmt::String for MarkdownWithToc<'a> {
impl<'a> fmt::Display for MarkdownWithToc<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let MarkdownWithToc(md) = *self;
render(fmt, md.as_slice(), true)

8
src/librustdoc/html/render.rs
View File

@ -1351,7 +1351,7 @@ impl<'a> Item<'a> {
}
impl<'a> fmt::String for Item<'a> {
impl<'a> fmt::Display for Item<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
// Write the breadcrumb trail header for the top
try!(write!(fmt, "\n<h1 class='fqn'><span class='in-band'>"));
@ -1626,7 +1626,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
struct Initializer<'a>(&'a str);
impl<'a> fmt::String for Initializer<'a> {
impl<'a> fmt::Display for Initializer<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Initializer(s) = *self;
if s.len() == 0 { return Ok(()); }
@ -2188,7 +2188,7 @@ fn item_typedef(w: &mut fmt::Formatter, it: &clean::Item,
document(w, it)
}
impl<'a> fmt::String for Sidebar<'a> {
impl<'a> fmt::Display for Sidebar<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let cx = self.cx;
let it = self.item;
@ -2243,7 +2243,7 @@ impl<'a> fmt::String for Sidebar<'a> {
}
}
impl<'a> fmt::String for Source<'a> {
impl<'a> fmt::Display for Source<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let Source(s) = *self;
let lines = s.lines().count();

6
src/librustdoc/html/toc.rs
View File

@ -176,13 +176,13 @@ impl TocBuilder {
}
}
impl fmt::Show for Toc {
impl fmt::Debug for Toc {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
fmt::Display::fmt(self, f)
}
}
impl fmt::String for Toc {
impl fmt::Display for Toc {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
try!(write!(fmt, "<ul>"));
for entry in self.entries.iter() {

2
src/librustdoc/lib.rs
View File

@ -111,7 +111,7 @@ pub fn main() {
let res = std::thread::Builder::new().stack_size(STACK_SIZE).scoped(move || {
main_args(std::os::args().as_slice())
}).join();
std::os::set_exit_status(res.map_err(|_| ()).unwrap());
std::os::set_exit_status(res.ok().unwrap());
}
pub fn opts() -> Vec<getopts::OptGroup> {

8
src/libserialize/base64.rs
View File

@ -177,7 +177,7 @@ pub trait FromBase64 {
}
/// Errors that can occur when decoding a base64 encoded string
#[derive(Copy)]
#[derive(Copy, Show)]
pub enum FromBase64Error {
/// The input contained a character not part of the base64 format
InvalidBase64Byte(u8, uint),
@ -185,7 +185,7 @@ pub enum FromBase64Error {
InvalidBase64Length,
}
impl fmt::Show for FromBase64Error {
impl fmt::Display for FromBase64Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InvalidBase64Byte(ch, idx) =>
@ -202,10 +202,6 @@ impl error::Error for FromBase64Error {
InvalidBase64Length => "invalid length",
}
}
fn detail(&self) -> Option<String> {
Some(format!("{:?}", self))
}
}
impl FromBase64 for str {

8
src/libserialize/hex.rs
View File

@ -61,7 +61,7 @@ pub trait FromHex {
}
/// Errors that can occur when decoding a hex encoded string
#[derive(Copy)]
#[derive(Copy, Show)]
pub enum FromHexError {
/// The input contained a character not part of the hex format
InvalidHexCharacter(char, uint),
@ -69,7 +69,7 @@ pub enum FromHexError {
InvalidHexLength,
}
impl fmt::Show for FromHexError {
impl fmt::Display for FromHexError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InvalidHexCharacter(ch, idx) =>
@ -86,10 +86,6 @@ impl error::Error for FromHexError {
InvalidHexLength => "invalid length",
}
}
fn detail(&self) -> Option<String> {
Some(format!("{:?}", self))
}
}

37
src/libserialize/json.rs
View File

@ -235,7 +235,7 @@ pub struct AsJson<'a, T: 'a> { inner: &'a T }
pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<uint> }
/// The errors that can arise while parsing a JSON stream.
#[derive(Clone, Copy, PartialEq)]
#[derive(Clone, Copy, PartialEq, Show)]
pub enum ErrorCode {
InvalidSyntax,
InvalidNumber,
@ -325,7 +325,7 @@ pub fn encode<T: ::Encodable>(object: &T) -> string::String {
s
}
impl fmt::Show for ErrorCode {
impl fmt::Display for ErrorCode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
error_str(*self).fmt(f)
}
@ -335,14 +335,33 @@ fn io_error_to_error(io: io::IoError) -> ParserError {
IoError(io.kind, io.desc)
}
impl fmt::Display for ParserError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// FIXME this should be a nicer error
fmt::Debug::fmt(self, f)
}
}
impl fmt::Display for DecoderError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// FIXME this should be a nicer error
fmt::Debug::fmt(self, f)
}
}
impl std::error::Error for DecoderError {
fn description(&self) -> &str { "decoder error" }
fn detail(&self) -> Option<std::string::String> { Some(format!("{:?}", self)) }
}
impl fmt::Display for EncoderError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// FIXME this should be a nicer error
fmt::Debug::fmt(self, f)
}
}
impl std::error::Error for EncoderError {
fn description(&self) -> &str { "encoder error" }
fn detail(&self) -> Option<std::string::String> { Some(format!("{:?}", self)) }
}
impl std::error::FromError<fmt::Error> for EncoderError {
@ -2519,7 +2538,7 @@ impl<'a, 'b> fmt::Writer for FormatShim<'a, 'b> {
}
}
impl fmt::String for Json {
impl fmt::Display for Json {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
@ -2531,7 +2550,7 @@ impl fmt::String for Json {
}
}
impl<'a> fmt::String for PrettyJson<'a> {
impl<'a> fmt::Display for PrettyJson<'a> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
@ -2543,7 +2562,7 @@ impl<'a> fmt::String for PrettyJson<'a> {
}
}
impl<'a, T: Encodable> fmt::String for AsJson<'a, T> {
impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
@ -2563,7 +2582,7 @@ impl<'a, T> AsPrettyJson<'a, T> {
}
}
impl<'a, T: Encodable> fmt::String for AsPrettyJson<'a, T> {
impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
@ -3920,7 +3939,7 @@ mod tests {
let mut mem_buf = Vec::new();
let mut encoder = Encoder::new(&mut mem_buf as &mut fmt::Writer);
let result = hm.encode(&mut encoder);
match result.unwrap_err() {
match result.err().unwrap() {
EncoderError::BadHashmapKey => (),
_ => panic!("expected bad hash map key")
}

12
src/libstd/collections/hash/map.rs
View File

@ -18,7 +18,7 @@ use borrow::BorrowFrom;
use clone::Clone;
use cmp::{max, Eq, PartialEq};
use default::Default;
use fmt::{self, Show};
use fmt::{self, Debug};
use hash::{self, Hash, SipHasher};
use iter::{self, Iterator, ExactSizeIterator, IteratorExt, FromIterator, Extend, Map};
use marker::Sized;
@ -270,7 +270,7 @@ fn test_resize_policy() {
/// ```
/// use std::collections::HashMap;
///
/// #[derive(Hash, Eq, PartialEq, Show)]
/// #[derive(Hash, Eq, PartialEq, Debug)]
/// struct Viking {
/// name: String,
/// country: String,
@ -1216,8 +1216,8 @@ impl<K, V, S, H> Eq for HashMap<K, V, S>
{}
#[stable]
impl<K, V, S, H> Show for HashMap<K, V, S>
where K: Eq + Hash<H> + Show, V: Show,
impl<K, V, S, H> Debug for HashMap<K, V, S>
where K: Eq + Hash<H> + Debug, V: Debug,
S: HashState<Hasher=H>,
H: hash::Hasher<Output=u64>
{
@ -1996,8 +1996,8 @@ mod test_map {
let map_str = format!("{:?}", map);
assert!(map_str == "HashMap {1i: 2i, 3i: 4i}" ||
map_str == "HashMap {3i: 4i, 1i: 2i}");
assert!(map_str == "HashMap {1: 2, 3: 4}" ||
map_str == "HashMap {3: 4, 1: 2}");
assert_eq!(format!("{:?}", empty), "HashMap {}");
}

10
src/libstd/collections/hash/set.rs
View File

@ -15,7 +15,7 @@ use clone::Clone;
use cmp::{Eq, PartialEq};
use core::marker::Sized;
use default::Default;
use fmt::Show;
use fmt::Debug;
use fmt;
use hash::{self, Hash};
use iter::{Iterator, ExactSizeIterator, IteratorExt, FromIterator, Map, Chain, Extend};
@ -71,7 +71,7 @@ use super::state::HashState;
///
/// ```
/// use std::collections::HashSet;
/// #[derive(Hash, Eq, PartialEq, Show)]
/// #[derive(Hash, Eq, PartialEq, Debug)]
/// struct Viking<'a> {
/// name: &'a str,
/// power: uint,
@ -596,8 +596,8 @@ impl<T, S, H> Eq for HashSet<T, S>
{}
#[stable]
impl<T, S, H> fmt::Show for HashSet<T, S>
where T: Eq + Hash<H> + fmt::Show,
impl<T, S, H> fmt::Debug for HashSet<T, S>
where T: Eq + Hash<H> + fmt::Debug,
S: HashState<Hasher=H>,
H: hash::Hasher<Output=u64>
{
@ -1179,7 +1179,7 @@ mod test_set {
let set_str = format!("{:?}", set);
assert!(set_str == "HashSet {1i, 2i}" || set_str == "HashSet {2i, 1i}");
assert!(set_str == "HashSet {1, 2}" || set_str == "HashSet {2, 1}");
assert_eq!(format!("{:?}", empty), "HashSet {}");
}

9
src/libstd/ffi/c_str.rs
View File

@ -119,7 +119,8 @@ impl Deref for CString {
}
}
impl fmt::Show for CString {
#[stable]
impl fmt::Debug for CString {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
String::from_utf8_lossy(self.as_bytes()).fmt(f)
}
@ -215,4 +216,10 @@ mod tests {
assert_eq!(s.as_bytes(), b"\0");
}
}
#[test]
fn formatted() {
let s = CString::from_slice(b"12");
assert_eq!(format!("{:?}", s), "\"12\"");
}
}

27
src/libstd/fmt.rs
View File

@ -123,8 +123,8 @@
//! This allows multiple actual types to be formatted via `{:x}` (like `i8` as
//! well as `int`). The current mapping of types to traits is:
//!
//! * *nothing* ⇒ `String`
//! * `?` ⇒ `Show`
//! * *nothing* ⇒ `Display`
//! * `?` ⇒ `Debug`
//! * `o` ⇒ `Octal`
//! * `x` ⇒ `LowerHex`
//! * `X` ⇒ `UpperHex`
@ -137,7 +137,7 @@
//! `std::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 `String` trait.
//! then the format trait used is the `Display` trait.
//!
//! When implementing a format trait for your own type, you will have to
//! implement a method of the signature:
@ -145,7 +145,7 @@
//! ```rust
//! # use std::fmt;
//! # struct Foo; // our custom type
//! # impl fmt::Show for Foo {
//! # impl fmt::Display for Foo {
//! fn fmt(&self, f: &mut std::fmt::Formatter) -> fmt::Result {
//! # write!(f, "testing, testing")
//! # } }
@ -171,13 +171,13 @@
//! use std::f64;
//! use std::num::Float;
//!
//! #[derive(Show)]
//! #[derive(Debug)]
//! struct Vector2D {
//! x: int,
//! y: int,
//! }
//!
//! impl fmt::String for Vector2D {
//! impl fmt::Display for Vector2D {
//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
//! // The `f` value implements the `Writer` trait, which is what the
//! // write! macro is expecting. Note that this formatting ignores the
@ -211,22 +211,22 @@
//! }
//! ```
//!
//! #### fmt::String vs fmt::Show
//! #### fmt::Display vs fmt::Debug
//!
//! These two formatting traits have distinct purposes:
//!
//! - `fmt::String` implementations assert that the type can be faithfully
//! - `fmt::Display` implementations assert that the type can be faithfully
//! represented as a UTF-8 string at all times. It is **not** expected that
//! all types implement the `String` trait.
//! - `fmt::Show` implementations should be implemented for **all** public types.
//! all types implement the `Display` trait.
//! - `fmt::Debug` implementations should be implemented for **all** public types.
//! Output will typically represent the internal state as faithfully as possible.
//! The purpose of the `Show` trait is to facilitate debugging Rust code. In
//! most cases, using `#[derive(Show)]` is sufficient and recommended.
//! The purpose of the `Debug` trait is to facilitate debugging Rust code. In
//! most cases, using `#[derive(Debug)]` is sufficient and recommended.
//!
//! Some examples of the output from both traits:
//!
//! ```
//! assert_eq!(format!("{} {:?}", 3i32, 4i32), "3 4i32");
//! assert_eq!(format!("{} {:?}", 3i32, 4i32), "3 4");
//! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'");
//! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\"");
//! ```
@ -409,6 +409,7 @@ use string;
pub use core::fmt::{Formatter, Result, Writer, rt};
pub use core::fmt::{Show, String, Octal, Binary};
pub use core::fmt::{Display, Debug};
pub use core::fmt::{LowerHex, UpperHex, Pointer};
pub use core::fmt::{LowerExp, UpperExp};
pub use core::fmt::Error;

12
src/libstd/io/buffered.rs
View File

@ -52,7 +52,8 @@ pub struct BufferedReader<R> {
cap: uint,
}
impl<R> fmt::Show for BufferedReader<R> where R: fmt::Show {
#[stable]
impl<R> fmt::Debug for BufferedReader<R> where R: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "BufferedReader {{ reader: {:?}, buffer: {}/{} }}",
self.inner, self.cap - self.pos, self.buf.len())
@ -150,7 +151,8 @@ pub struct BufferedWriter<W> {
pos: uint
}
impl<W> fmt::Show for BufferedWriter<W> where W: fmt::Show {
#[stable]
impl<W> fmt::Debug for BufferedWriter<W> where W: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "BufferedWriter {{ writer: {:?}, buffer: {}/{} }}",
self.inner.as_ref().unwrap(), self.pos, self.buf.len())
@ -249,7 +251,8 @@ pub struct LineBufferedWriter<W> {
inner: BufferedWriter<W>,
}
impl<W> fmt::Show for LineBufferedWriter<W> where W: fmt::Show {
#[stable]
impl<W> fmt::Debug for LineBufferedWriter<W> where W: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "LineBufferedWriter {{ writer: {:?}, buffer: {}/{} }}",
self.inner.inner, self.inner.pos, self.inner.buf.len())
@ -339,7 +342,8 @@ pub struct BufferedStream<S> {
inner: BufferedReader<InternalBufferedWriter<S>>
}
impl<S> fmt::Show for BufferedStream<S> where S: fmt::Show {
#[stable]
impl<S> fmt::Debug for BufferedStream<S> where S: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let reader = &self.inner;
let writer = &self.inner.inner.0;

50
src/libstd/io/fs.rs
View File

@ -156,7 +156,7 @@ impl File {
})
}
}).update_err("couldn't open path as file", |e| {
format!("{}; path={:?}; mode={}; access={}", e, path.display(),
format!("{}; path={}; mode={}; access={}", e, path.display(),
mode_string(mode), access_string(access))
})
}
@ -211,7 +211,7 @@ impl File {
pub fn fsync(&mut self) -> IoResult<()> {
self.fd.fsync()
.update_err("couldn't fsync file",
|e| format!("{}; path={:?}", e, self.path.display()))
|e| format!("{}; path={}", e, self.path.display()))
}
/// This function is similar to `fsync`, except that it may not synchronize
@ -221,7 +221,7 @@ impl File {
pub fn datasync(&mut self) -> IoResult<()> {
self.fd.datasync()
.update_err("couldn't datasync file",
|e| format!("{}; path={:?}", e, self.path.display()))
|e| format!("{}; path={}", e, self.path.display()))
}
/// Either truncates or extends the underlying file, updating the size of
@ -235,7 +235,7 @@ impl File {
pub fn truncate(&mut self, size: i64) -> IoResult<()> {
self.fd.truncate(size)
.update_err("couldn't truncate file", |e|
format!("{}; path={:?}; size={:?}", e, self.path.display(), size))
format!("{}; path={}; size={}", e, self.path.display(), size))
}
/// Returns true if the stream has reached the end of the file.
@ -255,7 +255,7 @@ impl File {
pub fn stat(&self) -> IoResult<FileStat> {
self.fd.fstat()
.update_err("couldn't fstat file", |e|
format!("{}; path={:?}", e, self.path.display()))
format!("{}; path={}", e, self.path.display()))
}
}
@ -283,7 +283,7 @@ impl File {
pub fn unlink(path: &Path) -> IoResult<()> {
fs_imp::unlink(path)
.update_err("couldn't unlink path", |e|
format!("{}; path={:?}", e, path.display()))
format!("{}; path={}", e, path.display()))
}
/// Given a path, query the file system to get information about a file,
@ -310,7 +310,7 @@ pub fn unlink(path: &Path) -> IoResult<()> {
pub fn stat(path: &Path) -> IoResult<FileStat> {
fs_imp::stat(path)
.update_err("couldn't stat path", |e|
format!("{}; path={:?}", e, path.display()))
format!("{}; path={}", e, path.display()))
}
/// Perform the same operation as the `stat` function, except that this
@ -324,7 +324,7 @@ pub fn stat(path: &Path) -> IoResult<FileStat> {
pub fn lstat(path: &Path) -> IoResult<FileStat> {
fs_imp::lstat(path)
.update_err("couldn't lstat path", |e|
format!("{}; path={:?}", e, path.display()))
format!("{}; path={}", e, path.display()))
}
/// Rename a file or directory to a new name.
@ -424,14 +424,14 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
pub fn chmod(path: &Path, mode: io::FilePermission) -> IoResult<()> {
fs_imp::chmod(path, mode.bits() as uint)
.update_err("couldn't chmod path", |e|
format!("{}; path={:?}; mode={:?}", e, path.display(), mode))
format!("{}; path={}; mode={:?}", e, path.display(), mode))
}
/// Change the user and group owners of a file at the specified path.
pub fn chown(path: &Path, uid: int, gid: int) -> IoResult<()> {
fs_imp::chown(path, uid, gid)
.update_err("couldn't chown path", |e|
format!("{}; path={:?}; uid={}; gid={}", e, path.display(), uid, gid))
format!("{}; path={}; uid={}; gid={}", e, path.display(), uid, gid))
}
/// Creates a new hard link on the filesystem. The `dst` path will be a
@ -460,7 +460,7 @@ pub fn symlink(src: &Path, dst: &Path) -> IoResult<()> {
pub fn readlink(path: &Path) -> IoResult<Path> {
fs_imp::readlink(path)
.update_err("couldn't resolve symlink for path", |e|
format!("{}; path={:?}", e, path.display()))
format!("{}; path={}", e, path.display()))
}
/// Create a new, empty directory at the provided path
@ -483,7 +483,7 @@ pub fn readlink(path: &Path) -> IoResult<Path> {
pub fn mkdir(path: &Path, mode: FilePermission) -> IoResult<()> {
fs_imp::mkdir(path, mode.bits() as uint)
.update_err("couldn't create directory", |e|
format!("{}; path={:?}; mode={:?}", e, path.display(), mode))
format!("{}; path={}; mode={}", e, path.display(), mode))
}
/// Remove an existing, empty directory
@ -505,7 +505,7 @@ pub fn mkdir(path: &Path, mode: FilePermission) -> IoResult<()> {
pub fn rmdir(path: &Path) -> IoResult<()> {
fs_imp::rmdir(path)
.update_err("couldn't remove directory", |e|
format!("{}; path={:?}", e, path.display()))
format!("{}; path={}", e, path.display()))
}
/// Retrieve a vector containing all entries within a provided directory
@ -545,7 +545,7 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
pub fn readdir(path: &Path) -> IoResult<Vec<Path>> {
fs_imp::readdir(path)
.update_err("couldn't read directory",
|e| format!("{}; path={:?}", e, path.display()))
|e| format!("{}; path={}", e, path.display()))
}
/// Returns an iterator that will recursively walk the directory structure
@ -555,7 +555,7 @@ pub fn readdir(path: &Path) -> IoResult<Vec<Path>> {
pub fn walk_dir(path: &Path) -> IoResult<Directories> {
Ok(Directories {
stack: try!(readdir(path).update_err("couldn't walk directory",
|e| format!("{}; path={:?}", e, path.display())))
|e| format!("{}; path={}", e, path.display())))
})
}
@ -605,7 +605,7 @@ pub fn mkdir_recursive(path: &Path, mode: FilePermission) -> IoResult<()> {
let result = mkdir(&curpath, mode)
.update_err("couldn't recursively mkdir",
|e| format!("{}; path={:?}", e, path.display()));
|e| format!("{}; path={}", e, path.display()));
match result {
Err(mkdir_err) => {
@ -632,7 +632,7 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
rm_stack.push(path.clone());
fn rmdir_failed(err: &IoError, path: &Path) -> String {
format!("rmdir_recursive failed; path={:?}; cause={}",
format!("rmdir_recursive failed; path={}; cause={}",
path.display(), err)
}
@ -692,14 +692,14 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
pub fn change_file_times(path: &Path, atime: u64, mtime: u64) -> IoResult<()> {
fs_imp::utime(path, atime, mtime)
.update_err("couldn't change_file_times", |e|
format!("{}; path={:?}", e, path.display()))
format!("{}; path={}", e, path.display()))
}
impl Reader for File {
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
fn update_err<T>(result: IoResult<T>, file: &File) -> IoResult<T> {
result.update_err("couldn't read file",
|e| format!("{}; path={:?}",
|e| format!("{}; path={}",
e, file.path.display()))
}
@ -722,7 +722,7 @@ impl Writer for File {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
self.fd.write(buf)
.update_err("couldn't write to file",
|e| format!("{}; path={:?}", e, self.path.display()))
|e| format!("{}; path={}", e, self.path.display()))
}
}
@ -730,7 +730,7 @@ impl Seek for File {
fn tell(&self) -> IoResult<u64> {
self.fd.tell()
.update_err("couldn't retrieve file cursor (`tell`)",
|e| format!("{}; path={:?}", e, self.path.display()))
|e| format!("{}; path={}", e, self.path.display()))
}
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
@ -743,7 +743,7 @@ impl Seek for File {
Err(e) => Err(e),
};
err.update_err("couldn't seek in file",
|e| format!("{}; path={:?}", e, self.path.display()))
|e| format!("{}; path={}", e, self.path.display()))
}
}
@ -906,7 +906,7 @@ mod test {
if cfg!(unix) {
error!(result, "no such file or directory");
}
error!(result, format!("path={:?}; mode=open; access=read", filename.display()));
error!(result, format!("path={}; mode=open; access=read", filename.display()));
}
#[test]
@ -920,7 +920,7 @@ mod test {
if cfg!(unix) {
error!(result, "no such file or directory");
}
error!(result, format!("path={:?}", filename.display()));
error!(result, format!("path={}", filename.display()));
}
#[test]
@ -1188,7 +1188,7 @@ mod test {
error!(result, "couldn't recursively mkdir");
error!(result, "couldn't create directory");
error!(result, "mode=0700");
error!(result, format!("path={:?}", file.display()));
error!(result, format!("path={}", file.display()));
}
#[test]

4
src/libstd/io/mem.rs
View File

@ -432,8 +432,8 @@ mod test {
writer.write(&[]).unwrap();
assert_eq!(writer.tell(), Ok(8));
assert_eq!(writer.write(&[8, 9]).unwrap_err().kind, io::ShortWrite(1));
assert_eq!(writer.write(&[10]).unwrap_err().kind, io::EndOfFile);
assert_eq!(writer.write(&[8, 9]).err().unwrap().kind, io::ShortWrite(1));
assert_eq!(writer.write(&[10]).err().unwrap().kind, io::EndOfFile);
}
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
assert_eq!(buf, b);

32
src/libstd/io/mod.rs
View File

@ -228,13 +228,12 @@ pub use self::FileAccess::*;
pub use self::IoErrorKind::*;
use char::CharExt;
use clone::Clone;
use default::Default;
use error::{FromError, Error};
use error::Error;
use fmt;
use int;
use iter::{Iterator, IteratorExt};
use marker::{Sized, Send};
use marker::Sized;
use mem::transmute;
use ops::FnOnce;
use option::Option;
@ -340,7 +339,8 @@ impl IoError {
}
}
impl fmt::String for IoError {
#[stable]
impl fmt::Display for IoError {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self {
IoError { kind: OtherIoError, desc: "unknown error", detail: Some(ref detail) } =>
@ -354,19 +354,7 @@ impl fmt::String for IoError {
}
impl Error for IoError {
fn description(&self) -> &str {
self.desc
}
fn detail(&self) -> Option<String> {
self.detail.clone()
}
}
impl FromError<IoError> for Box<Error + Send> {
fn from_error(err: IoError) -> Box<Error + Send> {
box err
}
fn description(&self) -> &str { self.desc }
}
/// A list specifying general categories of I/O error.
@ -1781,6 +1769,7 @@ pub struct UnstableFileStat {
bitflags! {
/// A set of permissions for a file or directory is represented by a set of
/// flags which are or'd together.
#[derive(Show)]
flags FilePermission: u32 {
const USER_READ = 0o400,
const USER_WRITE = 0o200,
@ -1822,13 +1811,8 @@ impl Default for FilePermission {
fn default() -> FilePermission { FilePermission::empty() }
}
impl fmt::Show for FilePermission {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
}
}
impl fmt::String for FilePermission {
#[stable]
impl fmt::Display for FilePermission {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:04o}", self.bits)
}

6
src/libstd/io/net/ip.rs
View File

@ -38,7 +38,8 @@ pub enum IpAddr {
Ipv6Addr(u16, u16, u16, u16, u16, u16, u16, u16)
}
impl fmt::String for IpAddr {
#[stable]
impl fmt::Display for IpAddr {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self {
Ipv4Addr(a, b, c, d) =>
@ -69,7 +70,8 @@ pub struct SocketAddr {
pub port: Port,
}
impl fmt::String for SocketAddr {
#[stable]
impl fmt::Display for SocketAddr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.ip {
Ipv4Addr(..) => write!(f, "{}:{}", self.ip, self.port),

15
src/libstd/io/process.rs
View File

@ -397,7 +397,7 @@ impl Command {
}
}
impl fmt::String for Command {
impl fmt::Debug for Command {
/// Format the program and arguments of a Command for display. Any
/// non-utf8 data is lossily converted using the utf8 replacement
/// character.
@ -496,7 +496,7 @@ pub enum StdioContainer {
/// Describes the result of a process after it has terminated.
/// Note that Windows have no signals, so the result is usually ExitStatus.
#[derive(PartialEq, Eq, Clone, Copy)]
#[derive(PartialEq, Eq, Clone, Copy, Show)]
pub enum ProcessExit {
/// Normal termination with an exit status.
ExitStatus(int),
@ -505,15 +505,8 @@ pub enum ProcessExit {
ExitSignal(int),
}
impl fmt::Show for ProcessExit {
/// Format a ProcessExit enum, to nicely present the information.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
}
}
impl fmt::String for ProcessExit {
#[stable]
impl fmt::Display for ProcessExit {
/// Format a ProcessExit enum, to nicely present the information.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {

2
src/libstd/lib.rs
View File

@ -168,6 +168,7 @@ pub use core::raw;
pub use core::simd;
pub use core::result;
pub use core::option;
pub use core::error;
#[cfg(not(test))] pub use alloc::boxed;
pub use alloc::rc;
@ -228,7 +229,6 @@ pub mod thunk;
/* Common traits */
pub mod error;
pub mod num;
/* Runtime and platform support */

4
src/libstd/num/mod.rs
View File

@ -16,7 +16,7 @@
#![stable]
#![allow(missing_docs)]
#[cfg(test)] use fmt::Show;
#[cfg(test)] use fmt::Debug;
use ops::{Add, Sub, Mul, Div, Rem, Neg};
use marker::Copy;
@ -322,7 +322,7 @@ pub fn test_num<T>(ten: T, two: T) where
T: PartialEq + NumCast
+ Add<Output=T> + Sub<Output=T>
+ Mul<Output=T> + Div<Output=T>
+ Rem<Output=T> + Show
+ Rem<Output=T> + Debug
+ Copy
{
assert_eq!(ten.add(two), cast(12i).unwrap());

12
src/libstd/os.rs
View File

@ -855,7 +855,7 @@ pub enum MapOption {
impl Copy for MapOption {}
/// Possible errors when creating a map.
#[derive(Copy)]
#[derive(Copy, Show)]
pub enum MapError {
/// # The following are POSIX-specific
///
@ -900,7 +900,8 @@ pub enum MapError {
ErrMapViewOfFile(uint)
}
impl fmt::Show for MapError {
#[stable]
impl fmt::Display for MapError {
fn fmt(&self, out: &mut fmt::Formatter) -> fmt::Result {
let str = match *self {
ErrFdNotAvail => "fd not available for reading or writing",
@ -934,13 +935,6 @@ impl fmt::Show for MapError {
impl Error for MapError {
fn description(&self) -> &str { "memory map error" }
fn detail(&self) -> Option<String> { Some(format!("{:?}", self)) }
}
impl FromError<MapError> for Box<Error + Send> {
fn from_error(err: MapError) -> Box<Error + Send> {
box err
}
}
// Round up `from` to be divisible by `to`

8
src/libstd/path/mod.rs
View File

@ -823,13 +823,15 @@ pub struct Display<'a, P:'a> {
filename: bool
}
impl<'a, P: GenericPath> fmt::Show for Display<'a, P> {
#[stable]
impl<'a, P: GenericPath> fmt::Debug for Display<'a, P> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
fmt::Debug::fmt(&self.as_cow(), f)
}
}
impl<'a, P: GenericPath> fmt::String for Display<'a, P> {
#[stable]
impl<'a, P: GenericPath> fmt::Display for Display<'a, P> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.as_cow().fmt(f)
}

5
src/libstd/path/posix.rs
View File

@ -57,9 +57,10 @@ pub fn is_sep(c: char) -> bool {
c == SEP
}
impl fmt::Show for Path {
#[stable]
impl fmt::Debug for Path {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(&self.display(), f)
fmt::Debug::fmt(&self.display(), f)
}
}

5
src/libstd/path/windows.rs
View File

@ -85,9 +85,10 @@ pub struct Path {
sepidx: Option<uint> // index of the final separator in the non-prefix portion of repr
}
impl fmt::Show for Path {
#[stable]
impl fmt::Debug for Path {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(&self.display(), f)
fmt::Debug::fmt(&self.display(), f)
}
}

20
src/libstd/sync/mpsc/mod.rs
View File

@ -393,7 +393,7 @@ impl<T> !marker::Sync for SyncSender<T> {}
/// A `send` operation can only fail if the receiving end of a channel is
/// disconnected, implying that the data could never be received. The error
/// contains the data being sent as a payload so it can be recovered.
#[derive(PartialEq, Eq)]
#[derive(PartialEq, Eq, Show)]
#[stable]
pub struct SendError<T>(pub T);
@ -401,13 +401,13 @@ pub struct SendError<T>(pub T);
///
/// The `recv` operation can only fail if the sending half of a channel is
/// disconnected, implying that no further messages will ever be received.
#[derive(PartialEq, Eq, Clone, Copy)]
#[derive(PartialEq, Eq, Clone, Copy, Show)]
#[stable]
pub struct RecvError;
/// This enumeration is the list of the possible reasons that try_recv could not
/// return data when called.
#[derive(PartialEq, Clone, Copy)]
#[derive(PartialEq, Clone, Copy, Show)]
#[stable]
pub enum TryRecvError {
/// This channel is currently empty, but the sender(s) have not yet
@ -423,7 +423,7 @@ pub enum TryRecvError {
/// This enumeration is the list of the possible error outcomes for the
/// `SyncSender::try_send` method.
#[derive(PartialEq, Clone)]
#[derive(PartialEq, Clone, Show)]
#[stable]
pub enum TrySendError<T> {
/// The data could not be sent on the channel because it would require that
@ -998,13 +998,15 @@ unsafe impl<T:Send> Send for RacyCell<T> { }
unsafe impl<T> Sync for RacyCell<T> { } // Oh dear
impl<T> fmt::Show for SendError<T> {
#[stable]
impl<T> fmt::Display for SendError<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
"sending on a closed channel".fmt(f)
}
}
impl<T> fmt::Show for TrySendError<T> {
#[stable]
impl<T> fmt::Display for TrySendError<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TrySendError::Full(..) => {
@ -1017,13 +1019,15 @@ impl<T> fmt::Show for TrySendError<T> {
}
}
impl fmt::Show for RecvError {
#[stable]
impl fmt::Display for RecvError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
"receiving on a closed channel".fmt(f)
}
}
impl fmt::Show for TryRecvError {
#[stable]
impl fmt::Display for TryRecvError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TryRecvError::Empty => {

8
src/libstd/sync/poison.rs
View File

@ -53,6 +53,7 @@ pub struct Guard {
/// is held. The precise semantics for when a lock is poisoned is documented on
/// each lock, but once a lock is poisoned then all future acquisitions will
/// return this error.
#[derive(Show)]
#[stable]
pub struct PoisonError<T> {
guard: T,
@ -60,6 +61,7 @@ pub struct PoisonError<T> {
/// An enumeration of possible errors which can occur while calling the
/// `try_lock` method.
#[derive(Show)]
#[stable]
pub enum TryLockError<T> {
/// The lock could not be acquired because another task failed while holding
@ -90,7 +92,8 @@ pub type LockResult<Guard> = Result<Guard, PoisonError<Guard>>;
#[stable]
pub type TryLockResult<Guard> = Result<Guard, TryLockError<Guard>>;
impl<T> fmt::Show for PoisonError<T> {
#[stable]
impl<T> fmt::Display for PoisonError<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.description().fmt(f)
}
@ -130,7 +133,8 @@ impl<T> FromError<PoisonError<T>> for TryLockError<T> {
}
}
impl<T> fmt::Show for TryLockError<T> {
#[stable]
impl<T> fmt::Display for TryLockError<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.description().fmt(f)
}

12
src/libstd/thread.rs
View File

@ -519,14 +519,14 @@ mod test {
fn test_unnamed_thread() {
Thread::scoped(move|| {
assert!(Thread::current().name().is_none());
}).join().map_err(|_| ()).unwrap();
}).join().ok().unwrap();
}
#[test]
fn test_named_thread() {
Builder::new().name("ada lovelace".to_string()).scoped(move|| {
assert!(Thread::current().name().unwrap() == "ada lovelace".to_string());
}).join().map_err(|_| ()).unwrap();
}).join().ok().unwrap();
}
#[test]
@ -662,7 +662,7 @@ mod test {
Err(e) => {
type T = &'static str;
assert!(e.is::<T>());
assert_eq!(*e.downcast::<T>().unwrap(), "static string");
assert_eq!(*e.downcast::<T>().ok().unwrap(), "static string");
}
Ok(()) => panic!()
}
@ -676,7 +676,7 @@ mod test {
Err(e) => {
type T = String;
assert!(e.is::<T>());
assert_eq!(*e.downcast::<T>().unwrap(), "owned string".to_string());
assert_eq!(*e.downcast::<T>().ok().unwrap(), "owned string".to_string());
}
Ok(()) => panic!()
}
@ -690,9 +690,9 @@ mod test {
Err(e) => {
type T = Box<Any + Send>;
assert!(e.is::<T>());
let any = e.downcast::<T>().unwrap();
let any = e.downcast::<T>().ok().unwrap();
assert!(any.is::<u16>());
assert_eq!(*any.downcast::<u16>().unwrap(), 413u16);
assert_eq!(*any.downcast::<u16>().ok().unwrap(), 413u16);
}
Ok(()) => panic!()
}

3
src/libstd/time/duration.rs
View File

@ -334,7 +334,8 @@ impl Div<i32> for Duration {
}
}
impl fmt::String for Duration {
#[stable]
impl fmt::Display for Duration {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// technically speaking, negative duration is not valid ISO 8601,
// but we need to print it anyway.

20
src/libsyntax/abi.rs
View File

@ -15,7 +15,7 @@ pub use self::AbiArchitecture::*;
use std::fmt;
#[derive(Copy, PartialEq)]
#[derive(Copy, PartialEq, Eq, Show)]
pub enum Os {
OsWindows,
OsMacos,
@ -26,7 +26,7 @@ pub enum Os {
OsDragonfly,
}
#[derive(PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Clone, Copy)]
#[derive(PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Clone, Copy, Show)]
pub enum Abi {
// NB: This ordering MUST match the AbiDatas array below.
// (This is ensured by the test indices_are_correct().)
@ -119,25 +119,13 @@ impl Abi {
}
}
impl fmt::Show for Abi {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
}
}
impl fmt::String for Abi {
impl fmt::Display for Abi {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "\"{}\"", self.name())
}
}
impl fmt::Show for Os {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
}
}
impl fmt::String for Os {
impl fmt::Display for Os {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
OsLinux => "linux".fmt(f),

51
src/libsyntax/ast.rs
View File

@ -100,28 +100,28 @@ impl Ident {
}
}
impl fmt::Show for Ident {
impl fmt::Debug for Ident {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}#{}", self.name, self.ctxt)
}
}
impl fmt::String for Ident {
impl fmt::Display for Ident {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&self.name, f)
fmt::Display::fmt(&self.name, f)
}
}
impl fmt::Show for Name {
impl fmt::Debug for Name {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Name(nm) = *self;
write!(f, "{:?}({})", token::get_name(*self).get(), nm)
}
}
impl fmt::String for Name {
impl fmt::Display for Name {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(token::get_name(*self).get(), f)
fmt::Display::fmt(token::get_name(*self).get(), f)
}
}
@ -1100,13 +1100,13 @@ impl PartialEq for IntTy {
}
}
impl fmt::Show for IntTy {
impl fmt::Debug for IntTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
fmt::Display::fmt(self, f)
}
}
impl fmt::String for IntTy {
impl fmt::Display for IntTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", ast_util::int_ty_to_string(*self, None))
}
@ -1155,13 +1155,13 @@ impl UintTy {
}
}
impl fmt::Show for UintTy {
impl fmt::Debug for UintTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
fmt::Display::fmt(self, f)
}
}
impl fmt::String for UintTy {
impl fmt::Display for UintTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", ast_util::uint_ty_to_string(*self, None))
}
@ -1173,13 +1173,13 @@ pub enum FloatTy {
TyF64,
}
impl fmt::Show for FloatTy {
impl fmt::Debug for FloatTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
fmt::Display::fmt(self, f)
}
}
impl fmt::String for FloatTy {
impl fmt::Display for FloatTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", ast_util::float_ty_to_string(*self))
}
@ -1222,24 +1222,15 @@ pub enum PrimTy {
TyChar
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy, Show)]
pub enum Onceness {
Once,
Many
}
impl fmt::Show for Onceness {
impl fmt::Display for Onceness {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(match *self {
Once => "once",
Many => "many",
}, f)
}
}
impl fmt::String for Onceness {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(match *self {
fmt::Display::fmt(match *self {
Once => "once",
Many => "many",
}, f)
@ -1358,9 +1349,9 @@ pub enum Unsafety {
Normal,
}
impl fmt::String for Unsafety {
impl fmt::Display for Unsafety {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(match *self {
fmt::Display::fmt(match *self {
Unsafety::Normal => "normal",
Unsafety::Unsafe => "unsafe",
}, f)
@ -1375,7 +1366,7 @@ pub enum ImplPolarity {
Negative,
}
impl fmt::Show for ImplPolarity {
impl fmt::Debug for ImplPolarity {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ImplPolarity::Positive => "positive".fmt(f),

2
src/libsyntax/ast_map/mod.rs
View File

@ -46,7 +46,7 @@ impl PathElem {
}
}
impl fmt::String for PathElem {
impl fmt::Display for PathElem {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let slot = token::get_name(self.name());
write!(f, "{}", slot)

4
src/libsyntax/attr.rs
View File

@ -358,9 +358,9 @@ pub enum StabilityLevel {
Locked
}
impl fmt::String for StabilityLevel {
impl fmt::Display for StabilityLevel {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(self, f)
fmt::Debug::fmt(self, f)
}
}

4
src/libsyntax/diagnostic.rs
View File

@ -235,9 +235,9 @@ pub enum Level {
Help,
}
impl fmt::String for Level {
impl fmt::Display for Level {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
use std::fmt::String;
use std::fmt::Display;
match *self {
Bug => "error: internal compiler error".fmt(f),

2
src/libsyntax/ext/deriving/mod.rs
View File

@ -99,7 +99,9 @@ pub fn expand_meta_derive(cx: &mut ExtCtxt,
"Rand" => expand!(rand::expand_deriving_rand),
// NOTE(stage0): remove "Show"
"Show" => expand!(show::expand_deriving_show),
"Debug" => expand!(show::expand_deriving_show),
"Default" => expand!(default::expand_deriving_default),

4
src/libsyntax/ext/deriving/show.rs
View File

@ -35,7 +35,7 @@ pub fn expand_deriving_show<F>(cx: &mut ExtCtxt,
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
path: Path::new(vec!("std", "fmt", "Show")),
path: Path::new(vec!("std", "fmt", "Debug")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
@ -67,7 +67,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span,
Struct(_) => substr.type_ident,
EnumMatching(_, v, _) => v.node.name,
EnumNonMatchingCollapsed(..) | StaticStruct(..) | StaticEnum(..) => {
cx.span_bug(span, "nonsensical .fields in `#[derive(Show)]`")
cx.span_bug(span, "nonsensical .fields in `#[derive(Debug)]`")
}
};

4
src/libsyntax/ext/format.rs
View File

@ -603,8 +603,8 @@ impl<'a, 'b> Context<'a, 'b> {
let trait_ = match *ty {
Known(ref tyname) => {
match &tyname[] {
"" => "String",
"?" => "Show",
"" => "Display",
"?" => "Debug",
"e" => "LowerExp",
"E" => "UpperExp",
"o" => "Octal",

2
src/libsyntax/owned_slice.rs
View File

@ -22,7 +22,7 @@ pub struct OwnedSlice<T> {
data: Box<[T]>
}
impl<T:fmt::Show> fmt::Show for OwnedSlice<T> {
impl<T:fmt::Debug> fmt::Debug for OwnedSlice<T> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
self.data.fmt(fmt)
}

8
src/libsyntax/parse/lexer/mod.rs
View File

@ -586,10 +586,10 @@ impl<'a> StringReader<'a> {
/// `\x00` marker.
#[inline(never)]
fn scan_embedded_hygienic_ident(&mut self) -> ast::Ident {
fn bump_expecting_char<'a,D:fmt::Show>(r: &mut StringReader<'a>,
c: char,
described_c: D,
whence: &str) {
fn bump_expecting_char<'a,D:fmt::Debug>(r: &mut StringReader<'a>,
c: char,
described_c: D,
whence: &str) {
match r.curr {
Some(r_c) if r_c == c => r.bump(),
Some(r_c) => panic!("expected {:?}, hit {:?}, {}", described_c, r_c, whence),

10
src/libsyntax/parse/token.rs
View File

@ -375,7 +375,7 @@ pub enum Nonterminal {
NtTT(P<ast::TokenTree>), // needs P'ed to break a circularity
}
impl fmt::Show for Nonterminal {
impl fmt::Debug for Nonterminal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
NtItem(..) => f.pad("NtItem(..)"),
@ -651,15 +651,15 @@ impl BytesContainer for InternedString {
}
}
impl fmt::Show for InternedString {
impl fmt::Debug for InternedString {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(self, f)
fmt::Debug::fmt(&self.string[], f)
}
}
impl fmt::String for InternedString {
impl fmt::Display for InternedString {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", &self.string[])
fmt::Display::fmt(&self.string[], f)
}
}

11
src/libsyntax/ptr.rs
View File

@ -36,7 +36,7 @@
//! implementation changes (using a special thread-local heap, for example).
//! Moreover, a switch to, e.g. `P<'a, T>` would be easy and mostly automated.
use std::fmt::{self, Show};
use std::fmt::{self, Display, Debug};
use std::hash::{Hash, Hasher};
use std::ops::Deref;
use std::ptr;
@ -100,9 +100,14 @@ impl<T: PartialEq> PartialEq for P<T> {
impl<T: Eq> Eq for P<T> {}
impl<T: Show> Show for P<T> {
impl<T: Debug> Debug for P<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
(**self).fmt(f)
Debug::fmt(&**self, f)
}
}
impl<T: Display> Display for P<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
Display::fmt(&**self, f)
}
}

Some files were not shown because too many files have changed in this diff Show More