Fix whitespacing issues in pretty-printing of bounds

src/librustc/hir/print.rs

@@ -408,15 +408,16 @@ pub fn print_type(&mut self, ty: &hir::Ty) -> io::Result<()> {
             hir::TyTraitObject(ref bounds, ref lifetime) => {
                 let mut first = true;
                 for bound in bounds {
-                    self.nbsp()?;
                     if first {
                         first = false;
                     } else {
+                        self.nbsp()?;
                         self.word_space("+")?;
                     }
                     self.print_poly_trait_ref(bound)?;
                 }
                 if !lifetime.is_elided() {
+                    self.nbsp()?;
                     self.word_space("+")?;
                     self.print_lifetime(lifetime)?;
                 }
@@ -764,7 +765,8 @@ pub fn print_item(&mut self, item: &hir::Item) -> io::Result<()> {
                         real_bounds.push(b.clone());
                     }
                 }
-                self.print_bounds(" = ", &real_bounds[..])?;
+                self.nbsp()?;
+                self.print_bounds("=", &real_bounds[..])?;
                 self.print_where_clause(&generics.where_clause)?;
                 self.s.word(";")?;
             }
@@ -788,6 +790,7 @@ fn print_formal_lifetime_list(&mut self, lifetimes: &[hir::LifetimeDef]) -> io::
                 comma = true;
             }
             self.s.word(">")?;
+            self.nbsp()?;
         }
         Ok(())
     }
@@ -2016,30 +2019,29 @@ pub fn print_bounds(&mut self, prefix: &str, bounds: &[hir::TyParamBound]) -> io
             self.s.word(prefix)?;
             let mut first = true;
             for bound in bounds {
-                self.nbsp()?;
+                if !(first && prefix.is_empty()) {
+                    self.nbsp()?;
+                }
                 if first {
                     first = false;
                 } else {
                     self.word_space("+")?;
                 }
 
-                match *bound {
-                    TraitTyParamBound(ref tref, TraitBoundModifier::None) => {
-                        self.print_poly_trait_ref(tref)
-                    }
-                    TraitTyParamBound(ref tref, TraitBoundModifier::Maybe) => {
-                        self.s.word("?")?;
-                        self.print_poly_trait_ref(tref)
+                match bound {
+                    TraitTyParamBound(tref, modifier) => {
+                        if modifier == &TraitBoundModifier::Maybe {
+                            self.s.word("?")?;
+                        }
+                        self.print_poly_trait_ref(tref)?;
                     }
-                    RegionTyParamBound(ref lt) => {
-                        self.print_lifetime(lt)
+                    RegionTyParamBound(lt) => {
+                        self.print_lifetime(lt)?;
                     }
-                }?
+                }
             }
-            Ok(())
-        } else {
-            Ok(())
         }
+        Ok(())
     }
 
     pub fn print_lifetime(&mut self, lifetime: &hir::Lifetime) -> io::Result<()> {

src/libsyntax/print/pprust.rs

@@ -1066,11 +1066,11 @@ pub fn print_type(&mut self, ty: &ast::Ty) -> io::Result<()> {
                 self.print_qpath(path, qself, false)?
             }
             ast::TyKind::TraitObject(ref bounds, syntax) => {
-                let prefix = if syntax == ast::TraitObjectSyntax::Dyn { "dyn " } else { "" };
+                let prefix = if syntax == ast::TraitObjectSyntax::Dyn { "dyn" } else { "" };
                 self.print_bounds(prefix, &bounds[..])?;
             }
             ast::TyKind::ImplTrait(ref bounds) => {
-                self.print_bounds("impl ", &bounds[..])?;
+                self.print_bounds("impl", &bounds[..])?;
             }
             ast::TyKind::Array(ref ty, ref v) => {
                 self.s.word("[")?;
@@ -1398,7 +1398,8 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                         real_bounds.push(b.clone());
                     }
                 }
-                self.print_bounds(" = ", &real_bounds[..])?;
+                self.nbsp()?;
+                self.print_bounds("=", &real_bounds[..])?;
                 self.print_where_clause(&generics.where_clause)?;
                 self.s.word(";")?;
             }
@@ -1444,6 +1445,7 @@ fn print_formal_lifetime_list(&mut self, lifetimes: &[ast::LifetimeDef]) -> io::
                 comma = true;
             }
             self.s.word(">")?;
+            self.nbsp()?;
         }
         Ok(())
     }
@@ -2818,30 +2820,29 @@ pub fn print_bounds(&mut self,
             self.s.word(prefix)?;
             let mut first = true;
             for bound in bounds {
-                self.nbsp()?;
+                if !(first && prefix.is_empty()) {
+                    self.nbsp()?;
+                }
                 if first {
                     first = false;
                 } else {
                     self.word_space("+")?;
                 }
 
-                (match *bound {
-                    TraitTyParamBound(ref tref, TraitBoundModifier::None) => {
-                        self.print_poly_trait_ref(tref)
-                    }
-                    TraitTyParamBound(ref tref, TraitBoundModifier::Maybe) => {
-                        self.s.word("?")?;
-                        self.print_poly_trait_ref(tref)
+                match bound {
+                    TraitTyParamBound(tref, modifier) => {
+                        if modifier == &TraitBoundModifier::Maybe {
+                            self.s.word("?")?;
+                        }
+                        self.print_poly_trait_ref(tref)?;
                     }
-                    RegionTyParamBound(ref lt) => {
-                        self.print_lifetime(lt)
+                    RegionTyParamBound(lt) => {
+                        self.print_lifetime(lt)?;
                     }
-                })?
+                }
             }
-            Ok(())
-        } else {
-            Ok(())
         }
+        Ok(())
     }
 
     pub fn print_lifetime(&mut self,

src/test/parse-fail/trait-object-bad-parens.rs

@@ -14,9 +14,9 @@ fn main() {
     let _: Box<((Copy)) + Copy>;
     //~^ ERROR expected a path on the left-hand side of `+`, not `((Copy))`
     let _: Box<(Copy + Copy) + Copy>;
-    //~^ ERROR expected a path on the left-hand side of `+`, not `( Copy + Copy)`
+    //~^ ERROR expected a path on the left-hand side of `+`, not `(Copy + Copy)`
     let _: Box<(Copy +) + Copy>;
-    //~^ ERROR expected a path on the left-hand side of `+`, not `( Copy)`
+    //~^ ERROR expected a path on the left-hand side of `+`, not `(Copy)`
     let _: Box<(dyn Copy) + Copy>;
-    //~^ ERROR expected a path on the left-hand side of `+`, not `(dyn  Copy)`
+    //~^ ERROR expected a path on the left-hand side of `+`, not `(dyn Copy)`
 }

src/test/parse-fail/trait-object-polytrait-priority.rs

@@ -12,7 +12,7 @@ trait Trait<'a> {}
 
 fn main() {
     let _: &for<'a> Trait<'a> + 'static;
-    //~^ ERROR expected a path on the left-hand side of `+`, not `& for<'a>Trait<'a>`
+    //~^ ERROR expected a path on the left-hand side of `+`, not `&for<'a> Trait<'a>`
     //~| HELP try adding parentheses
-    //~| SUGGESTION &( for<'a>Trait<'a> + 'static)
+    //~| SUGGESTION &(for<'a> Trait<'a> + 'static)
 }

src/test/pretty/closure-reform-pretty.rs

@@ -17,7 +17,7 @@ fn call_it(f: Box<FnMut(String) -> String>) { }
 
 fn call_this<F>(f: F) where F: Fn(&str) + Send { }
 
-fn call_that<F>(f: F) where F: for<'a>Fn(&'a isize, &'a isize) -> isize { }
+fn call_that<F>(f: F) where F: for<'a> Fn(&'a isize, &'a isize) -> isize { }
 
 fn call_extern(f: fn() -> isize) { }
 

src/test/pretty/path-type-bounds.rs

@@ -16,10 +16,10 @@ fn dummy(&self) { }
 }
 impl Tr for isize { }
 
-fn foo<'a>(x: Box< Tr + Sync + 'a>) -> Box< Tr + Sync + 'a> { x }
+fn foo<'a>(x: Box<Tr + Sync + 'a>) -> Box<Tr + Sync + 'a> { x }
 
 fn main() {
-    let x: Box< Tr + Sync>;
+    let x: Box<Tr + Sync>;
 
-    Box::new(1isize) as Box< Tr + Sync>;
+    Box::new(1isize) as Box<Tr + Sync>;
 }