diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 09404af7027..de98bc63183 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -16,6 +16,7 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering}; use core::default::Default; use core::fmt; use core::intrinsics; +use core::kinds::Sized; use core::mem; use core::option::Option; use core::raw::TraitObject; @@ -120,7 +121,7 @@ impl BoxAny for Box { } } -impl fmt::Show for Box { +impl fmt::Show for Box { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { (**self).fmt(f) } diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 65107d6ab7d..5000b020985 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -16,7 +16,7 @@ use any; use cell::{Cell, Ref, RefMut}; use collections::Collection; use iter::{Iterator, range}; -use kinds::Copy; +use kinds::{Copy, Sized}; use mem; use option::{Option, Some, None}; use ops::Deref; @@ -168,85 +168,85 @@ impl<'a> Show for Arguments<'a> { /// When a format is not otherwise specified, types are formatted by ascribing /// to this trait. There is not an explicit way of selecting this trait to be /// used for formatting, it is only if no other format is specified. -pub trait Show { +pub trait Show for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `b` character -pub trait Bool { +pub trait Bool for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `c` character -pub trait Char { +pub trait Char for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `i` and `d` characters -pub trait Signed { +pub trait Signed for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `u` character -pub trait Unsigned { +pub trait Unsigned for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `o` character -pub trait Octal { +pub trait Octal for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `t` character -pub trait Binary { +pub trait Binary for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `x` character -pub trait LowerHex { +pub trait LowerHex for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `X` character -pub trait UpperHex { +pub trait UpperHex for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `s` character -pub trait String { +pub trait String for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `p` character -pub trait Pointer { +pub trait Pointer for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `f` character -pub trait Float { +pub trait Float for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `e` character -pub trait LowerExp { +pub trait LowerExp for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } /// Format trait for the `E` character -pub trait UpperExp { +pub trait UpperExp for Sized? { /// Formats the value using the given formatter. fn fmt(&self, &mut Formatter) -> Result; } @@ -257,7 +257,7 @@ macro_rules! uniform_fn_call_workaround { ($( $name: ident, $trait_: ident; )*) => { $( #[doc(hidden)] - pub fn $name(x: &T, fmt: &mut Formatter) -> Result { + pub fn $name(x: &T, fmt: &mut Formatter) -> Result { x.fmt(fmt) } )* @@ -583,10 +583,10 @@ pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> { // Implementations of the core formatting traits -impl<'a, T: Show> Show for &'a T { +impl<'a, Sized? T: Show> Show for &'a T { fn fmt(&self, f: &mut Formatter) -> Result { secret_show(*self, f) } } -impl<'a, T: Show> Show for &'a mut T { +impl<'a, Sized? T: Show> Show for &'a mut T { fn fmt(&self, f: &mut Formatter) -> Result { secret_show(&**self, f) } } impl<'a> Show for &'a Show+'a { @@ -599,12 +599,18 @@ impl Bool for bool { } } -impl<'a, T: str::Str> String for T { +impl String for T { fn fmt(&self, f: &mut Formatter) -> Result { f.pad(self.as_slice()) } } +impl String for str { + fn fmt(&self, f: &mut Formatter) -> Result { + f.pad(self) + } +} + impl Char for char { fn fmt(&self, f: &mut Formatter) -> Result { use char::Char; @@ -708,13 +714,13 @@ floating!(f64) // Implementation of Show for various core types macro_rules! delegate(($ty:ty to $other:ident) => { - impl<'a> Show for $ty { + impl Show for $ty { fn fmt(&self, f: &mut Formatter) -> Result { (concat_idents!(secret_, $other)(self, f)) } } }) -delegate!(&'a str to string) +delegate!(str to string) delegate!(bool to bool) delegate!(char to char) delegate!(f32 to float) @@ -761,7 +767,7 @@ impl<'a> Show for &'a any::Any+'a { fn fmt(&self, f: &mut Formatter) -> Result { f.pad("&Any") } } -impl<'a, T: Show> Show for &'a [T] { +impl Show for [T] { fn fmt(&self, f: &mut Formatter) -> Result { if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 { try!(write!(f, "[")); @@ -782,12 +788,6 @@ impl<'a, T: Show> Show for &'a [T] { } } -impl<'a, T: Show> Show for &'a mut [T] { - fn fmt(&self, f: &mut Formatter) -> Result { - secret_show(&self.as_slice(), f) - } -} - impl Show for () { fn fmt(&self, f: &mut Formatter) -> Result { f.pad("()") diff --git a/src/test/run-pass/show-boxed-slice.rs b/src/test/run-pass/show-boxed-slice.rs new file mode 100644 index 00000000000..3d267265332 --- /dev/null +++ b/src/test/run-pass/show-boxed-slice.rs @@ -0,0 +1,16 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[deriving(Show)] +struct Foo(Box<[u8]>); + +pub fn main() { + println!("{}", Foo(box [0, 1, 2])); +}