Fix whitespacing issues in pretty-printing of bounds

petrochenkov · petrochenkov · commit 7a95e716c731 · 2017-12-20T00:23:18.000+03:00
diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
@@ -408,15 +408,16 @@ impl<'a> State<'a> {
             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 @@ impl<'a> State<'a> {
                         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 @@ impl<'a> State<'a> {
                 comma = true;
             }
             self.s.word(">")?;
+            self.nbsp()?;
         }
         Ok(())
     }
@@ -2016,30 +2019,29 @@ impl<'a> State<'a> {
             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<()> {
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -1066,11 +1066,11 @@ impl<'a> State<'a> {
                 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 @@ impl<'a> State<'a> {
                         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 @@ impl<'a> State<'a> {
                 comma = true;
             }
             self.s.word(">")?;
+            self.nbsp()?;
         }
         Ok(())
     }
@@ -2818,30 +2820,29 @@ impl<'a> State<'a> {
             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,
diff --git a/src/test/parse-fail/trait-object-bad-parens.rs b/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)`
 }
diff --git a/src/test/parse-fail/trait-object-polytrait-priority.rs b/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)
 }
diff --git a/src/test/pretty/closure-reform-pretty.rs b/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) { }
 
diff --git a/src/test/pretty/path-type-bounds.rs b/src/test/pretty/path-type-bounds.rs
@@ -16,10 +16,10 @@ trait Tr {
 }
 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>;
 }

Original file line number	Diff line number	Diff line change
`@@ -408,15 +408,16 @@ impl<'a> State<'a> {`
`408`	`408`	`hir::TyTraitObject(ref bounds, ref lifetime) => {`
`409`	`409`	`let mut first = true;`
`410`	`410`	`for bound in bounds {`
`411`		`- self.nbsp()?;`
`412`	`411`	`if first {`
`413`	`412`	`first = false;`
`414`	`413`	`} else {`
	`414`	`+ self.nbsp()?;`
`415`	`415`	`self.word_space("+")?;`
`416`	`416`	`}`
`417`	`417`	`self.print_poly_trait_ref(bound)?;`
`418`	`418`	`}`
`419`	`419`	`if !lifetime.is_elided() {`
	`420`	`+ self.nbsp()?;`
`420`	`421`	`self.word_space("+")?;`
`421`	`422`	`self.print_lifetime(lifetime)?;`
`422`	`423`	`}`
`@@ -764,7 +765,8 @@ impl<'a> State<'a> {`
`764`	`765`	`real_bounds.push(b.clone());`
`765`	`766`	`}`
`766`	`767`	`}`
`767`		`- self.print_bounds(" = ", &real_bounds[..])?;`
	`768`	`+ self.nbsp()?;`
	`769`	`+ self.print_bounds("=", &real_bounds[..])?;`
`768`	`770`	`self.print_where_clause(&generics.where_clause)?;`
`769`	`771`	`self.s.word(";")?;`
`770`	`772`	`}`
`@@ -788,6 +790,7 @@ impl<'a> State<'a> {`
`788`	`790`	`comma = true;`
`789`	`791`	`}`
`790`	`792`	`self.s.word(">")?;`
	`793`	`+ self.nbsp()?;`
`791`	`794`	`}`
`792`	`795`	`Ok(())`
`793`	`796`	`}`
`@@ -2016,30 +2019,29 @@ impl<'a> State<'a> {`
`2016`	`2019`	`self.s.word(prefix)?;`
`2017`	`2020`	`let mut first = true;`
`2018`	`2021`	`for bound in bounds {`
`2019`		`- self.nbsp()?;`
	`2022`	`+ if !(first && prefix.is_empty()) {`
	`2023`	`+ self.nbsp()?;`
	`2024`	`+ }`
`2020`	`2025`	`if first {`
`2021`	`2026`	`first = false;`
`2022`	`2027`	`} else {`
`2023`	`2028`	`self.word_space("+")?;`
`2024`	`2029`	`}`
`2025`	`2030`
`2026`		`- match *bound {`
`2027`		`- TraitTyParamBound(ref tref, TraitBoundModifier::None) => {`
`2028`		`- self.print_poly_trait_ref(tref)`
`2029`		`- }`
`2030`		`- TraitTyParamBound(ref tref, TraitBoundModifier::Maybe) => {`
`2031`		`- self.s.word("?")?;`
`2032`		`- self.print_poly_trait_ref(tref)`
	`2031`	`+ match bound {`
	`2032`	`+ TraitTyParamBound(tref, modifier) => {`
	`2033`	`+ if modifier == &TraitBoundModifier::Maybe {`
	`2034`	`+ self.s.word("?")?;`
	`2035`	`+ }`
	`2036`	`+ self.print_poly_trait_ref(tref)?;`
`2033`	`2037`	`}`
`2034`		`- RegionTyParamBound(ref lt) => {`
`2035`		`- self.print_lifetime(lt)`
	`2038`	`+ RegionTyParamBound(lt) => {`
	`2039`	`+ self.print_lifetime(lt)?;`
`2036`	`2040`	`}`
`2037`		`- }?`
	`2041`	`+ }`
`2038`	`2042`	`}`
`2039`		`- Ok(())`
`2040`		`- } else {`
`2041`		`- Ok(())`
`2042`	`2043`	`}`
	`2044`	`+ Ok(())`
`2043`	`2045`	`}`
`2044`	`2046`
`2045`	`2047`	`pub fn print_lifetime(&mut self, lifetime: &hir::Lifetime) -> io::Result<()> {`
Original file line number	Diff line number	Diff line change
`@@ -1066,11 +1066,11 @@ impl<'a> State<'a> {`
`1066`	`1066`	`self.print_qpath(path, qself, false)?`
`1067`	`1067`	`}`
`1068`	`1068`	`ast::TyKind::TraitObject(ref bounds, syntax) => {`
`1069`		`- let prefix = if syntax == ast::TraitObjectSyntax::Dyn { "dyn " } else { "" };`
	`1069`	`+ let prefix = if syntax == ast::TraitObjectSyntax::Dyn { "dyn" } else { "" };`
`1070`	`1070`	`self.print_bounds(prefix, &bounds[..])?;`
`1071`	`1071`	`}`
`1072`	`1072`	`ast::TyKind::ImplTrait(ref bounds) => {`
`1073`		`- self.print_bounds("impl ", &bounds[..])?;`
	`1073`	`+ self.print_bounds("impl", &bounds[..])?;`
`1074`	`1074`	`}`
`1075`	`1075`	`ast::TyKind::Array(ref ty, ref v) => {`
`1076`	`1076`	`self.s.word("[")?;`
`@@ -1398,7 +1398,8 @@ impl<'a> State<'a> {`
`1398`	`1398`	`real_bounds.push(b.clone());`
`1399`	`1399`	`}`
`1400`	`1400`	`}`
`1401`		`- self.print_bounds(" = ", &real_bounds[..])?;`
	`1401`	`+ self.nbsp()?;`
	`1402`	`+ self.print_bounds("=", &real_bounds[..])?;`
`1402`	`1403`	`self.print_where_clause(&generics.where_clause)?;`
`1403`	`1404`	`self.s.word(";")?;`
`1404`	`1405`	`}`
`@@ -1444,6 +1445,7 @@ impl<'a> State<'a> {`
`1444`	`1445`	`comma = true;`
`1445`	`1446`	`}`
`1446`	`1447`	`self.s.word(">")?;`
	`1448`	`+ self.nbsp()?;`
`1447`	`1449`	`}`
`1448`	`1450`	`Ok(())`
`1449`	`1451`	`}`
`@@ -2818,30 +2820,29 @@ impl<'a> State<'a> {`
`2818`	`2820`	`self.s.word(prefix)?;`
`2819`	`2821`	`let mut first = true;`
`2820`	`2822`	`for bound in bounds {`
`2821`		`- self.nbsp()?;`
	`2823`	`+ if !(first && prefix.is_empty()) {`
	`2824`	`+ self.nbsp()?;`
	`2825`	`+ }`
`2822`	`2826`	`if first {`
`2823`	`2827`	`first = false;`
`2824`	`2828`	`} else {`
`2825`	`2829`	`self.word_space("+")?;`
`2826`	`2830`	`}`
`2827`	`2831`
`2828`		`- (match *bound {`
`2829`		`- TraitTyParamBound(ref tref, TraitBoundModifier::None) => {`
`2830`		`- self.print_poly_trait_ref(tref)`
`2831`		`- }`
`2832`		`- TraitTyParamBound(ref tref, TraitBoundModifier::Maybe) => {`
`2833`		`- self.s.word("?")?;`
`2834`		`- self.print_poly_trait_ref(tref)`
	`2832`	`+ match bound {`
	`2833`	`+ TraitTyParamBound(tref, modifier) => {`
	`2834`	`+ if modifier == &TraitBoundModifier::Maybe {`
	`2835`	`+ self.s.word("?")?;`
	`2836`	`+ }`
	`2837`	`+ self.print_poly_trait_ref(tref)?;`
`2835`	`2838`	`}`
`2836`		`- RegionTyParamBound(ref lt) => {`
`2837`		`- self.print_lifetime(lt)`
	`2839`	`+ RegionTyParamBound(lt) => {`
	`2840`	`+ self.print_lifetime(lt)?;`
`2838`	`2841`	`}`
`2839`		`- })?`
	`2842`	`+ }`
`2840`	`2843`	`}`
`2841`		`- Ok(())`
`2842`		`- } else {`
`2843`		`- Ok(())`
`2844`	`2844`	`}`
	`2845`	`+ Ok(())`
`2845`	`2846`	`}`
`2846`	`2847`
`2847`	`2848`	`pub fn print_lifetime(&mut self,`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ trait Trait<'a> {}`
`12`	`12`
`13`	`13`	`fn main() {`
`14`	`14`	`let _: &for<'a> Trait<'a> + 'static;`
`15`		- //~^ ERROR expected a path on the left-hand side of `+`, not `& for<'a>Trait<'a>`
	`15`	+ //~^ ERROR expected a path on the left-hand side of `+`, not `&for<'a> Trait<'a>`
`16`	`16`	`//~\| HELP try adding parentheses`
`17`		`- //~\| SUGGESTION &( for<'a>Trait<'a> + 'static)`
	`17`	`+ //~\| SUGGESTION &(for<'a> Trait<'a> + 'static)`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,10 +16,10 @@ trait Tr {`
`16`	`16`	`}`
`17`	`17`	`impl Tr for isize { }`
`18`	`18`
`19`		`-fn foo<'a>(x: Box< Tr + Sync + 'a>) -> Box< Tr + Sync + 'a> { x }`
	`19`	`+fn foo<'a>(x: Box<Tr + Sync + 'a>) -> Box<Tr + Sync + 'a> { x }`
`20`	`20`
`21`	`21`	`fn main() {`
`22`		`- let x: Box< Tr + Sync>;`
	`22`	`+ let x: Box<Tr + Sync>;`
`23`	`23`
`24`		`- Box::new(1isize) as Box< Tr + Sync>;`
	`24`	`+ Box::new(1isize) as Box<Tr + Sync>;`
`25`	`25`	`}`