user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

std: Rename Show/String to Debug/Display

Browse source 
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
Download patch file Download diff file Expand all files Collapse all files

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 {