---

yaml
---
r: 130487
b: refs/heads/try
c: 2bc4a5e
h: refs/heads/master
i:
  130485: fc39560
  130483: 05cd1d4
  130479: c03bcdc
v: v3

Author: wickerwaka

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c964cb229bd342bdeb0b4506c3a6d32b03e575f6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67b97ab6d2b7de9b69fd97dc171fcf8feec932ff
-refs/heads/try: 8d5e64f3bc2f754bed4b5a1857dd3494c5049c50
+refs/heads/try: 2bc4a5e92aef51bd34a5b1a506c5edcee893d6ac
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/fmt/mod.rs

@@ -461,19 +461,28 @@ impl<'a> Formatter<'a> {
         use char::Char;
         let align = match self.align {
             rt::AlignUnknown => default,
-            rt::AlignLeft | rt::AlignRight => self.align
+            _ => self.align
         };
-        if align == rt::AlignLeft {
-            try!(f(self));
-        }
+
+        let (pre_pad, post_pad) = match align {
+            rt::AlignLeft => (0u, padding),
+            rt::AlignRight | rt::AlignUnknown => (padding, 0u),
+            rt::AlignCenter => (padding / 2, (padding + 1) / 2),
+        };
+
         let mut fill = [0u8, ..4];
         let len = self.fill.encode_utf8(fill).unwrap_or(0);
-        for _ in range(0, padding) {
+
+        for _ in range(0, pre_pad) {
             try!(self.buf.write(fill.slice_to(len)));
         }
-        if align == rt::AlignRight {
-            try!(f(self));
+
+        try!(f(self));
+
+        for _ in range(0, post_pad) {
+            try!(self.buf.write(fill.slice_to(len)));
         }
+
         Ok(())
     }
 

branches/try/src/libcore/fmt/rt.rs

@@ -43,6 +43,8 @@ pub enum Alignment {
     AlignLeft,
     /// Indication that contents should be right-aligned.
     AlignRight,
+    /// Indication that contents should be center-aligned.
+    AlignCenter,
     /// No alignment was requested.
     AlignUnknown,
 }

branches/try/src/libfmt_macros/lib.rs

@@ -81,6 +81,8 @@ pub enum Alignment {
     AlignLeft,
     /// The value will be aligned to the right.
     AlignRight,
+    /// The value will be aligned in the center.
+    AlignCenter,
     /// The value will take on a default alignment.
     AlignUnknown,
 }
@@ -279,7 +281,7 @@ impl<'a> Parser<'a> {
         match self.cur.clone().next() {
             Some((_, c)) => {
                 match self.cur.clone().skip(1).next() {
-                    Some((_, '>')) | Some((_, '<')) => {
+                    Some((_, '>')) | Some((_, '<')) | Some((_, '^')) => {
                         spec.fill = Some(c);
                         self.cur.next();
                     }
@@ -293,6 +295,8 @@ impl<'a> Parser<'a> {
             spec.align = AlignLeft;
         } else if self.consume('>') {
             spec.align = AlignRight;
+        } else if self.consume('^') {
+            spec.align = AlignCenter;
         }
         // Sign flags
         if self.consume('+') {

branches/try/src/liblibc/lib.rs

@@ -4542,7 +4542,7 @@ pub mod funcs {
                 pub fn glob(pattern: *const c_char,
                             flags: c_int,
                             errfunc: ::Nullable<extern "C" fn(epath: *const c_char,
-                                                              errno: c_int) -> c_int>,
+                                                              errno: c_int) -> int>,
                             pglob: *mut glob_t);
                 pub fn globfree(pglob: *mut glob_t);
             }

branches/try/src/librustc/lint/builtin.rs

@@ -45,7 +45,6 @@ use syntax::attr;
 use syntax::codemap::Span;
 use syntax::parse::token;
 use syntax::{ast, ast_util, visit};
-use syntax::visit::Visitor;
 
 declare_lint!(WHILE_TRUE, Warn,
               "suggest using `loop { }` instead of `while true { }`")
@@ -340,51 +339,6 @@ impl LintPass for TypeLimits {
 declare_lint!(CTYPES, Warn,
               "proper use of libc types in foreign modules")
 
-struct CTypesVisitor<'a> {
-    cx: &'a Context<'a>
-}
-
-impl<'a> CTypesVisitor<'a> {
-    fn check_def(&mut self, sp: Span, ty_id: ast::NodeId, path_id: ast::NodeId) {
-        match self.cx.tcx.def_map.borrow().get_copy(&path_id) {
-            def::DefPrimTy(ast::TyInt(ast::TyI)) => {
-                self.cx.span_lint(CTYPES, sp,
-                                  "found rust type `int` in foreign module, while \
-                                   libc::c_int or libc::c_long should be used");
-            }
-            def::DefPrimTy(ast::TyUint(ast::TyU)) => {
-                self.cx.span_lint(CTYPES, sp,
-                                  "found rust type `uint` in foreign module, while \
-                                   libc::c_uint or libc::c_ulong should be used");
-            }
-            def::DefTy(..) => {
-                let tty = match self.cx.tcx.ast_ty_to_ty_cache.borrow().find(&ty_id) {
-                    Some(&ty::atttce_resolved(t)) => t,
-                    _ => fail!("ast_ty_to_ty_cache was incomplete after typeck!")
-                };
-
-                if !ty::is_ffi_safe(self.cx.tcx, tty) {
-                    self.cx.span_lint(CTYPES, sp,
-                                      "found type without foreign-function-safe
-                                      representation annotation in foreign module, consider \
-                                      adding a #[repr(...)] attribute to the type");
-                }
-            }
-            _ => ()
-        }
-    }
-}
-
-impl<'a> Visitor<()> for CTypesVisitor<'a> {
-    fn visit_ty(&mut self, ty: &ast::Ty, _: ()) {
-        match ty.node {
-            ast::TyPath(_, _, id) => self.check_def(ty.span, ty.id, id),
-            _ => (),
-        }
-        visit::walk_ty(self, ty, ());
-    }
-}
-
 pub struct CTypes;
 
 impl LintPass for CTypes {
@@ -394,8 +348,38 @@ impl LintPass for CTypes {
 
     fn check_item(&mut self, cx: &Context, it: &ast::Item) {
         fn check_ty(cx: &Context, ty: &ast::Ty) {
-            let mut vis = CTypesVisitor { cx: cx };
-            vis.visit_ty(ty, ());
+            match ty.node {
+                ast::TyPath(_, _, id) => {
+                    match cx.tcx.def_map.borrow().get_copy(&id) {
+                        def::DefPrimTy(ast::TyInt(ast::TyI)) => {
+                            cx.span_lint(CTYPES, ty.span,
+                                         "found rust type `int` in foreign module, while \
+                                          libc::c_int or libc::c_long should be used");
+                        }
+                        def::DefPrimTy(ast::TyUint(ast::TyU)) => {
+                            cx.span_lint(CTYPES, ty.span,
+                                         "found rust type `uint` in foreign module, while \
+                                          libc::c_uint or libc::c_ulong should be used");
+                        }
+                        def::DefTy(..) => {
+                            let tty = match cx.tcx.ast_ty_to_ty_cache.borrow().find(&ty.id) {
+                                Some(&ty::atttce_resolved(t)) => t,
+                                _ => fail!("ast_ty_to_ty_cache was incomplete after typeck!")
+                            };
+
+                            if !ty::is_ffi_safe(cx.tcx, tty) {
+                                cx.span_lint(CTYPES, ty.span,
+                                             "found type without foreign-function-safe
+                                             representation annotation in foreign module, consider \
+                                             adding a #[repr(...)] attribute to the type");
+                            }
+                        }
+                        _ => ()
+                    }
+                }
+                ast::TyPtr(ref mt) => { check_ty(cx, &*mt.ty) }
+                _ => {}
+            }
         }
 
         fn check_foreign_fn(cx: &Context, decl: &ast::FnDecl) {
@@ -406,15 +390,15 @@ impl LintPass for CTypes {
         }
 
         match it.node {
-            ast::ItemForeignMod(ref nmod) if nmod.abi != abi::RustIntrinsic => {
-                for ni in nmod.items.iter() {
-                    match ni.node {
-                        ast::ForeignItemFn(decl, _) => check_foreign_fn(cx, &*decl),
-                        ast::ForeignItemStatic(t, _) => check_ty(cx, &*t)
-                    }
+          ast::ItemForeignMod(ref nmod) if nmod.abi != abi::RustIntrinsic => {
+            for ni in nmod.items.iter() {
+                match ni.node {
+                    ast::ForeignItemFn(decl, _) => check_foreign_fn(cx, &*decl),
+                    ast::ForeignItemStatic(t, _) => check_ty(cx, &*t)
                 }
             }
-            _ => (),
+          }
+          _ => {/* nothing to do */ }
         }
     }
 }
@@ -509,7 +493,7 @@ struct RawPtrDerivingVisitor<'a> {
     cx: &'a Context<'a>
 }
 
-impl<'a> Visitor<()> for RawPtrDerivingVisitor<'a> {
+impl<'a> visit::Visitor<()> for RawPtrDerivingVisitor<'a> {
     fn visit_ty(&mut self, ty: &ast::Ty, _: ()) {
         static MSG: &'static str = "use of `#[deriving]` with a raw pointer";
         match ty.node {

branches/try/src/libstd/fmt.rs

@@ -333,7 +333,7 @@ argument := integer | identifier
 
 format_spec := [[fill]align][sign]['#'][0][width]['.' precision][type]
 fill := character
-align := '<' | '>'
+align := '<' | '^' | '>'
 sign := '+' | '-'
 width := count
 precision := count | '*'
@@ -357,6 +357,7 @@ parameter. This indicates that if the value being formatted is smaller than
 are specified by `fill`, and the alignment can be one of two options:
 
 * `<` - the argument is left-aligned in `width` columns
+* `^` - the argument is center-aligned in `width` columns
 * `>` - the argument is right-aligned in `width` columns
 
 ### Sign/#/0

branches/try/src/libsyntax/ext/format.rs

@@ -430,6 +430,9 @@ impl<'a, 'b> Context<'a, 'b> {
                     parse::AlignRight => {
                         self.ecx.path_global(sp, self.rtpath("AlignRight"))
                     }
+                    parse::AlignCenter => {
+                        self.ecx.path_global(sp, self.rtpath("AlignCenter"))
+                    }
                     parse::AlignUnknown => {
                         self.ecx.path_global(sp, self.rtpath("AlignUnknown"))
                     }

branches/try/src/libtime/lib.rs

@@ -232,8 +232,6 @@ pub fn tzset() {
 
 /// Holds a calendar date and time broken down into its components (year, month, day, and so on),
 /// also called a broken-down time value.
-// FIXME: use c_int instead of i32?
-#[repr(C)]
 #[deriving(Clone, PartialEq, Eq, Show)]
 pub struct Tm {
     /// Seconds after the minute - [0, 60]

branches/try/src/test/compile-fail/issue-16250.rs

@@ -90,11 +90,16 @@ pub fn main() {
     t!(format!("{:4s}", "a"), "a   ");
     t!(format!("{:>4s}", "a"), "   a");
     t!(format!("{:<4s}", "a"), "a   ");
+    t!(format!("{:^5s}", "a"),  "  a  ");
+    t!(format!("{:^5s}", "aa"), " aa  ");
+    t!(format!("{:^4s}", "a"),  " a  ");
+    t!(format!("{:^4s}", "aa"), " aa ");
     t!(format!("{:.4s}", "a"), "a");
     t!(format!("{:4.4s}", "a"), "a   ");
     t!(format!("{:4.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
     t!(format!("{:<4.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
     t!(format!("{:>4.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
+    t!(format!("{:^4.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
     t!(format!("{:>10.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
     t!(format!("{:2.4s}", "aaaaa"), "aaaa");
     t!(format!("{:2.4s}", "aaaa"), "aaaa");