---

yaml
---
r: 110895
b: refs/heads/auto
c: 44e34c2
h: refs/heads/master
i:
  110893: 5449229
  110891: f38dbb7
  110887: 400a812
  110879: d91c4b9
v: v3

Author: alexcrichton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 296e60be6b027a52de58251848037a92f23a0878
+refs/heads/auto: 44e34c24c4752408038f95225f536d11605c5ba4
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustc/front/feature_gate.rs

@@ -96,7 +96,7 @@ impl<'a> Context<'a> {
     fn gate_feature(&self, feature: &str, span: Span, explain: &str) {
         if !self.has_feature(feature) {
             self.sess.span_err(span, explain);
-            self.sess.span_note(span, format!("add \\#![feature({})] to the \
+            self.sess.span_note(span, format!("add \\#[feature({})] to the \
                                                   crate attributes to enable",
                                                  feature));
         }

branches/auto/src/librustc/middle/typeck/check/mod.rs

@@ -3698,7 +3698,7 @@ pub fn instantiate_path(fcx: &FnCtxt,
             && !fcx.tcx().sess.features.default_type_params.get() {
             fcx.tcx().sess.span_err(pth.span, "default type parameters are \
                                                experimental and possibly buggy");
-            fcx.tcx().sess.span_note(pth.span, "add #![feature(default_type_params)] \
+            fcx.tcx().sess.span_note(pth.span, "add #[feature(default_type_params)] \
                                                 to the crate attributes to enable");
         }
 

branches/auto/src/librustc/util/ppaux.rs

@@ -341,8 +341,10 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> ~str {
       ty_bot => ~"!",
       ty_bool => ~"bool",
       ty_char => ~"char",
-      ty_int(t) => ast_util::int_ty_to_str(t, None),
-      ty_uint(t) => ast_util::uint_ty_to_str(t, None),
+      ty_int(ast::TyI) => ~"int",
+      ty_int(t) => ast_util::int_ty_to_str(t),
+      ty_uint(ast::TyU) => ~"uint",
+      ty_uint(t) => ast_util::uint_ty_to_str(t),
       ty_float(t) => ast_util::float_ty_to_str(t),
       ty_box(typ) => ~"@" + ty_to_str(cx, typ),
       ty_uniq(typ) => ~"~" + ty_to_str(cx, typ),

branches/auto/src/librustdoc/html/format.rs

@@ -279,18 +279,17 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
 }
 
 /// Helper to render type parameters
-fn typarams(w: &mut io::Writer,
+fn tybounds(w: &mut io::Writer,
             typarams: &Option<Vec<clean::TyParamBound> >) -> fmt::Result {
     match *typarams {
         Some(ref params) => {
-            try!(write!(w, "&lt;"));
+            try!(write!(w, ":"));
             for (i, param) in params.iter().enumerate() {
                 if i > 0 {
-                    try!(write!(w, ", "));
+                    try!(write!(w, " + "));
                 }
                 try!(write!(w, "{}", *param));
             }
-            try!(write!(w, "&gt;"));
             Ok(())
         }
         None => Ok(())
@@ -308,13 +307,13 @@ impl fmt::Show for clean::Type {
             }
             clean::ResolvedPath{id, typarams: ref tp, path: ref path} => {
                 try!(resolved_path(f.buf, id, path, false));
-                typarams(f.buf, tp)
+                tybounds(f.buf, tp)
             }
             clean::ExternalPath{path: ref path, typarams: ref tp,
                                 fqn: ref fqn, kind, krate} => {
                 try!(external_path(f.buf, path, false, fqn.as_slice(), kind,
                                      krate))
-                typarams(f.buf, tp)
+                tybounds(f.buf, tp)
             }
             clean::Self(..) => f.buf.write("Self".as_bytes()),
             clean::Primitive(prim) => {
@@ -338,26 +337,59 @@ impl fmt::Show for clean::Type {
                 f.buf.write(s.as_bytes())
             }
             clean::Closure(ref decl, ref region) => {
-                let region = match *region {
-                    Some(ref region) => format!("{} ", *region),
-                    None => ~"",
-                };
-
-                write!(f.buf, "{}{}|{}|{arrow, select, yes{ -&gt; {ret}} other{}}",
-                       FnStyleSpace(decl.fn_style),
-                       region,
-                       decl.decl.inputs,
+                write!(f.buf, "{style}{lifetimes}|{args}|{bounds}\
+                               {arrow, select, yes{ -&gt; {ret}} other{}}",
+                       style = FnStyleSpace(decl.fn_style),
+                       lifetimes = if decl.lifetimes.len() == 0 {
+                           ~""
+                       } else {
+                           format!("&lt;{:#}&gt;", decl.lifetimes)
+                       },
+                       args = decl.decl.inputs,
                        arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" },
-                       ret = decl.decl.output)
-                // FIXME: where are bounds and lifetimes printed?!
+                       ret = decl.decl.output,
+                       bounds = {
+                           let mut ret = StrBuf::new();
+                           match *region {
+                               Some(ref lt) => {
+                                   ret.push_str(format!(": {}", *lt));
+                               }
+                               None => {}
+                           }
+                           for bound in decl.bounds.iter() {
+                                match *bound {
+                                    clean::RegionBound => {}
+                                    clean::TraitBound(ref t) => {
+                                        if ret.len() == 0 {
+                                            ret.push_str(": ");
+                                        } else {
+                                            ret.push_str(" + ");
+                                        }
+                                        ret.push_str(format!("{}", *t));
+                                    }
+                                }
+                           }
+                           ret.into_owned()
+                       })
             }
             clean::Proc(ref decl) => {
-                write!(f.buf, "{}proc({}){arrow, select, yes{ -&gt; {ret}} other{}}",
-                       FnStyleSpace(decl.fn_style),
-                       decl.decl.inputs,
+                write!(f.buf, "{style}{lifetimes}proc({args}){bounds}\
+                               {arrow, select, yes{ -&gt; {ret}} other{}}",
+                       style = FnStyleSpace(decl.fn_style),
+                       lifetimes = if decl.lifetimes.len() == 0 {
+                           ~""
+                       } else {
+                           format!("&lt;{:#}&gt;", decl.lifetimes)
+                       },
+                       args = decl.decl.inputs,
+                       bounds = if decl.bounds.len() == 0 {
+                           ~""
+                       } else {
+                           let mut m = decl.bounds.iter().map(|s| s.to_str());
+                           ": " + m.collect::<~[~str]>().connect(" + ")
+                       },
                        arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" },
                        ret = decl.decl.output)
-                // FIXME: where are bounds and lifetimes printed?!
             }
             clean::BareFunction(ref decl) => {
                 write!(f.buf, "{}{}fn{}{}",

branches/auto/src/libstd/num/mod.rs

@@ -159,7 +159,6 @@ pub fn abs_sub<T: Signed>(x: T, y: T) -> T {
 /// - `-1` if the number is negative
 #[inline(always)] pub fn signum<T: Signed>(value: T) -> T { value.signum() }
 
-/// A trait for values which cannot be negative
 pub trait Unsigned: Num {}
 
 /// A collection of rounding operations.
@@ -206,7 +205,6 @@ pub fn pow<T: One + Mul<T, T>>(mut base: T, mut exp: uint) -> T {
     }
 }
 
-/// Numbers which have upper and lower bounds
 pub trait Bounded {
     // FIXME (#5527): These should be associated constants
     fn min_value() -> Self;
@@ -1048,12 +1046,10 @@ impl_num_cast!(int,   to_int)
 impl_num_cast!(f32,   to_f32)
 impl_num_cast!(f64,   to_f64)
 
-/// A generic trait for converting a value to a string with a radix (base)
 pub trait ToStrRadix {
     fn to_str_radix(&self, radix: uint) -> ~str;
 }
 
-/// A generic trait for converting a string with a radix (base) to a value
 pub trait FromStrRadix {
     fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
 }

branches/auto/src/libstd/slice.rs

@@ -2601,7 +2601,9 @@ impl<A: Clone> Clone for ~[A] {
 
 impl<'a, T: fmt::Show> fmt::Show for &'a [T] {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f.buf, "["));
+        if f.flags & (1 << (fmt::parse::FlagAlternate as uint)) == 0 {
+            try!(write!(f.buf, "["));
+        }
         let mut is_first = true;
         for x in self.iter() {
             if is_first {
@@ -2611,7 +2613,10 @@ impl<'a, T: fmt::Show> fmt::Show for &'a [T] {
             }
             try!(write!(f.buf, "{}", *x))
         }
-        write!(f.buf, "]")
+        if f.flags & (1 << (fmt::parse::FlagAlternate as uint)) == 0 {
+            try!(write!(f.buf, "]"));
+        }
+        Ok(())
     }
 }
 

branches/auto/src/libsyntax/ast.rs

@@ -707,7 +707,7 @@ pub enum IntTy {
 
 impl fmt::Show for IntTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, "{}", ast_util::int_ty_to_str(*self, None))
+        write!(f.buf, "{}", ast_util::int_ty_to_str(*self))
     }
 }
 
@@ -722,7 +722,7 @@ pub enum UintTy {
 
 impl fmt::Show for UintTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, "{}", ast_util::uint_ty_to_str(*self, None))
+        write!(f.buf, "{}", ast_util::uint_ty_to_str(*self))
     }
 }
 

branches/auto/src/libsyntax/ast_util.rs

@@ -132,21 +132,13 @@ pub fn is_path(e: @Expr) -> bool {
     return match e.node { ExprPath(_) => true, _ => false };
 }
 
-// Get a string representation of a signed int type, with its value.
-// We want to avoid "45int" and "-3int" in favor of "45" and "-3"
-pub fn int_ty_to_str(t: IntTy, val: Option<i64>) -> ~str {
-    let s = match t {
-        TyI if val.is_some() => "",
-        TyI => "int",
-        TyI8 => "i8",
-        TyI16 => "i16",
-        TyI32 => "i32",
-        TyI64 => "i64"
-    };
-
-    match val {
-        Some(n) => format!("{}{}", n, s),
-        None => s.to_owned()
+pub fn int_ty_to_str(t: IntTy) -> ~str {
+    match t {
+        TyI => ~"",
+        TyI8 => ~"i8",
+        TyI16 => ~"i16",
+        TyI32 => ~"i32",
+        TyI64 => ~"i64"
     }
 }
 
@@ -159,21 +151,13 @@ pub fn int_ty_max(t: IntTy) -> u64 {
     }
 }
 
-// Get a string representation of an unsigned int type, with its value.
-// We want to avoid "42uint" in favor of "42u"
-pub fn uint_ty_to_str(t: UintTy, val: Option<u64>) -> ~str {
-    let s = match t {
-        TyU if val.is_some() => "u",
-        TyU => "uint",
-        TyU8 => "u8",
-        TyU16 => "u16",
-        TyU32 => "u32",
-        TyU64 => "u64"
-    };
-
-    match val {
-        Some(n) => format!("{}{}", n, s),
-        None => s.to_owned()
+pub fn uint_ty_to_str(t: UintTy) -> ~str {
+    match t {
+        TyU => ~"u",
+        TyU8 => ~"u8",
+        TyU16 => ~"u16",
+        TyU32 => ~"u32",
+        TyU64 => ~"u64"
     }
 }
 

branches/auto/src/libsyntax/parse/token.rs

@@ -201,8 +201,12 @@ pub fn to_str(t: &Token) -> ~str {
           res.push_char('\'');
           res.into_owned()
       }
-      LIT_INT(i, t) => ast_util::int_ty_to_str(t, Some(i)),
-      LIT_UINT(u, t) => ast_util::uint_ty_to_str(t, Some(u)),
+      LIT_INT(i, t) => {
+          i.to_str() + ast_util::int_ty_to_str(t)
+      }
+      LIT_UINT(u, t) => {
+          u.to_str() + ast_util::uint_ty_to_str(t)
+      }
       LIT_INT_UNSUFFIXED(i) => { i.to_str() }
       LIT_FLOAT(s, t) => {
         let mut body = StrBuf::from_str(get_ident(s).get());

branches/auto/src/libsyntax/print/pprust.rs

@@ -2171,10 +2171,10 @@ impl<'a> State<'a> {
                 word(&mut self.s, res.into_owned())
             }
             ast::LitInt(i, t) => {
-                word(&mut self.s, ast_util::int_ty_to_str(t, Some(i)))
+                word(&mut self.s, format!("{}{}", i, ast_util::int_ty_to_str(t)))
             }
             ast::LitUint(u, t) => {
-                word(&mut self.s, ast_util::uint_ty_to_str(t, Some(u)))
+                word(&mut self.s, format!("{}{}", u, ast_util::uint_ty_to_str(t)))
             }
             ast::LitIntUnsuffixed(i) => {
                 word(&mut self.s, format!("{}", i))