DSTify Show and all the other formatting traits

diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 09404af70273381330b2701b4b16531744f775f5..de98bc63183a24d6b80273035486fc675a597a2e 100644 (file)
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -16,6 +16,7 @@
 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 @@ fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any+'static>> {
     }
 }
 
-impl<T: fmt::Show> fmt::Show for Box<T> {
+impl<Sized? T: fmt::Show> fmt::Show for Box<T> {
     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 093f5896aad2d98a80db15001aeeb149f5c9d0be..ee50452ee27189665417fbb756ece5bebecb094f 100644 (file)
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -16,7 +16,7 @@
 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 @@ fn fmt(&self, fmt: &mut Formatter) -> Result {
 /// 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<T: $trait_>(x: &T, fmt: &mut Formatter) -> Result {
+            pub fn $name<Sized? T: $trait_>(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 @@ fn fmt(&self, f: &mut Formatter) -> Result {
     }
 }
 
-impl<'a, T: str::Str> String for T {
+impl<T: str::Str> 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 @@ fn fmt(&self, fmt: &mut Formatter) -> Result {
 // 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<T: Show> 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 @@ fn fmt(&self, f: &mut Formatter) -> Result {
     }
 }
 
-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 (file)
index 0000000..3d26726
--- /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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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]));
+}