use fmt::Result where applicable

llogiq · llogiq · commit e333725664c4 · 2018-05-09T02:01:37.000+02:00
diff --git a/src/librustc/ich/fingerprint.rs b/src/librustc/ich/fingerprint.rs
@@ -67,7 +67,7 @@ impl Fingerprint {
 }
 
 impl ::std::fmt::Display for Fingerprint {
-    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+    fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         write!(formatter, "{:x}-{:x}", self.0, self.1)
     }
 }
diff --git a/src/librustc_data_structures/control_flow_graph/dominators/mod.rs b/src/librustc_data_structures/control_flow_graph/dominators/mod.rs
@@ -175,7 +175,7 @@ impl<Node: Idx> DominatorTree<Node> {
 }
 
 impl<Node: Idx> fmt::Debug for DominatorTree<Node> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(&DominatorTreeNode {
                             tree: self,
                             node: self.root,
@@ -190,7 +190,7 @@ struct DominatorTreeNode<'tree, Node: Idx> {
 }
 
 impl<'tree, Node: Idx> fmt::Debug for DominatorTreeNode<'tree, Node> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let subtrees: Vec<_> = self.tree
             .children(self.node)
             .iter()
diff --git a/src/librustc_data_structures/owning_ref/mod.rs b/src/librustc_data_structures/owning_ref/mod.rs
@@ -1002,7 +1002,7 @@ impl<O, T: ?Sized> Debug for OwningRef<O, T>
     where O: Debug,
           T: Debug,
 {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f,
                "OwningRef {{ owner: {:?}, reference: {:?} }}",
                self.owner(),
@@ -1014,7 +1014,7 @@ impl<O, T: ?Sized> Debug for OwningRefMut<O, T>
     where O: Debug,
           T: Debug,
 {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f,
                "OwningRefMut {{ owner: {:?}, reference: {:?} }}",
                self.owner(),
@@ -1047,7 +1047,7 @@ unsafe impl<O, T: ?Sized> Sync for OwningRefMut<O, T>
     where O: Sync, for<'a> (&'a mut T): Sync {}
 
 impl Debug for Erased {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "<Erased>",)
     }
 }
diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs
@@ -232,7 +232,7 @@ impl FatalError {
 }
 
 impl fmt::Display for FatalError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "parser fatal error")
     }
 }
@@ -249,7 +249,7 @@ impl error::Error for FatalError {
 pub struct ExplicitBug;
 
 impl fmt::Display for ExplicitBug {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "parser internal bug")
     }
 }
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs
@@ -1185,7 +1185,7 @@ impl<'tcx> RegionDefinition<'tcx> {
 }
 
 impl fmt::Debug for Constraint {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         write!(
             formatter,
             "({:?}: {:?} @ {:?}) due to {:?}",
diff --git a/src/librustc_mir/transform/elaborate_drops.rs b/src/librustc_mir/transform/elaborate_drops.rs
@@ -174,7 +174,7 @@ struct Elaborator<'a, 'b: 'a, 'tcx: 'b> {
 }
 
 impl<'a, 'b, 'tcx> fmt::Debug for Elaborator<'a, 'b, 'tcx> {
-    fn fmt(&self, _f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {
         Ok(())
     }
 }
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
@@ -2579,7 +2579,7 @@ fn item_function(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
 }
 
 fn render_implementor(cx: &Context, implementor: &Impl, w: &mut fmt::Formatter,
-                      implementor_dups: &FxHashMap<&str, (DefId, bool)>) -> Result<(), fmt::Error> {
+                      implementor_dups: &FxHashMap<&str, (DefId, bool)>) -> fmt::Result {
     write!(w, "<li><table class='table-display'><tbody><tr><td><code>")?;
     // If there's already another implementor that has the same abbridged name, use the
     // full path, for example in `std::iter::ExactSizeIterator`
@@ -2612,7 +2612,7 @@ fn render_implementor(cx: &Context, implementor: &Impl, w: &mut fmt::Formatter,
 
 fn render_impls(cx: &Context, w: &mut fmt::Formatter,
                 traits: &[&&Impl],
-                containing_item: &clean::Item) -> Result<(), fmt::Error> {
+                containing_item: &clean::Item) -> fmt::Result {
     for i in traits {
         let did = i.trait_did().unwrap();
         let assoc_link = AssocItemLink::GotoSource(did, &i.inner_impl().provided_trait_methods);
diff --git a/src/libstd/path.rs b/src/libstd/path.rs
@@ -1460,7 +1460,7 @@ impl<P: AsRef<Path>> iter::Extend<P> for PathBuf {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Debug for PathBuf {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(&**self, formatter)
     }
 }
diff --git a/src/libstd/sys/redox/syscall/error.rs b/src/libstd/sys/redox/syscall/error.rs
@@ -48,13 +48,13 @@ impl Error {
 }
 
 impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(self.text())
     }
 }
 
 impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(self.text())
     }
 }
diff --git a/src/libstd/sys_common/wtf8.rs b/src/libstd/sys_common/wtf8.rs
@@ -56,7 +56,7 @@ pub struct CodePoint {
 /// Example: `U+1F4A9`
 impl fmt::Debug for CodePoint {
     #[inline]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         write!(formatter, "U+{:04X}", self.value)
     }
 }
@@ -144,7 +144,7 @@ impl ops::DerefMut for Wtf8Buf {
 /// Example: `"a\u{D800}"` for a string with code points [U+0061, U+D800]
 impl fmt::Debug for Wtf8Buf {
     #[inline]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(&**self, formatter)
     }
 }
diff --git a/src/libsyntax_ext/format_foreign.rs b/src/libsyntax_ext/format_foreign.rs
@@ -989,7 +989,7 @@ mod strcursor {
     }
 
     impl<'a> std::fmt::Debug for StrCursor<'a> {
-        fn fmt(&self, fmt: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
             write!(fmt, "StrCursor({:?} | {:?})", self.slice_before(), self.slice_after())
         }
     }
diff --git a/src/test/run-pass/atomic-print.rs b/src/test/run-pass/atomic-print.rs
@@ -15,7 +15,7 @@ use std::{env, fmt, process, sync, thread};
 
 struct SlowFmt(u32);
 impl fmt::Debug for SlowFmt {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         thread::sleep_ms(3);
         self.0.fmt(f)
     }
diff --git a/src/test/run-pass/union/union-trait-impl.rs b/src/test/run-pass/union/union-trait-impl.rs
@@ -15,7 +15,7 @@ union U {
 }
 
 impl fmt::Display for U {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         unsafe { write!(f, "Oh hai {}", self.a) }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ impl Fingerprint {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`impl ::std::fmt::Display for Fingerprint {`
`70`		`- fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {`
	`70`	`+ fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {`
`71`	`71`	`write!(formatter, "{:x}-{:x}", self.0, self.1)`
`72`	`72`	`}`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1002,7 +1002,7 @@ impl<O, T: ?Sized> Debug for OwningRef<O, T>`
`1002`	`1002`	`where O: Debug,`
`1003`	`1003`	`T: Debug,`
`1004`	`1004`	`{`
`1005`		`- fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`1005`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`1006`	`1006`	`write!(f,`
`1007`	`1007`	`"OwningRef {{ owner: {:?}, reference: {:?} }}",`
`1008`	`1008`	`self.owner(),`
`@@ -1014,7 +1014,7 @@ impl<O, T: ?Sized> Debug for OwningRefMut<O, T>`
`1014`	`1014`	`where O: Debug,`
`1015`	`1015`	`T: Debug,`
`1016`	`1016`	`{`
`1017`		`- fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`1017`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`1018`	`1018`	`write!(f,`
`1019`	`1019`	`"OwningRefMut {{ owner: {:?}, reference: {:?} }}",`
`1020`	`1020`	`self.owner(),`
`@@ -1047,7 +1047,7 @@ unsafe impl<O, T: ?Sized> Sync for OwningRefMut<O, T>`
`1047`	`1047`	`where O: Sync, for<'a> (&'a mut T): Sync {}`
`1048`	`1048`
`1049`	`1049`	`impl Debug for Erased {`
`1050`		`- fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`1050`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`1051`	`1051`	`write!(f, "<Erased>",)`
`1052`	`1052`	`}`
`1053`	`1053`	`}`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ impl FatalError {`
`232`	`232`	`}`
`233`	`233`
`234`	`234`	`impl fmt::Display for FatalError {`
`235`		`- fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`235`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`236`	`236`	`write!(f, "parser fatal error")`
`237`	`237`	`}`
`238`	`238`	`}`
`@@ -249,7 +249,7 @@ impl error::Error for FatalError {`
`249`	`249`	`pub struct ExplicitBug;`
`250`	`250`
`251`	`251`	`impl fmt::Display for ExplicitBug {`
`252`		`- fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`252`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`253`	`253`	`write!(f, "parser internal bug")`
`254`	`254`	`}`
`255`	`255`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1185,7 +1185,7 @@ impl<'tcx> RegionDefinition<'tcx> {`
`1185`	`1185`	`}`
`1186`	`1186`
`1187`	`1187`	`impl fmt::Debug for Constraint {`
`1188`		`- fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`1188`	`+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {`
`1189`	`1189`	`write!(`
`1190`	`1190`	`formatter,`
`1191`	`1191`	`"({:?}: {:?} @ {:?}) due to {:?}",`
Original file line number	Diff line number	Diff line change
`@@ -174,7 +174,7 @@ struct Elaborator<'a, 'b: 'a, 'tcx: 'b> {`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`impl<'a, 'b, 'tcx> fmt::Debug for Elaborator<'a, 'b, 'tcx> {`
`177`		`- fn fmt(&self, _f: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`177`	`+ fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {`
`178`	`178`	`Ok(())`
`179`	`179`	`}`
`180`	`180`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1460,7 +1460,7 @@ impl<P: AsRef<Path>> iter::Extend<P> for PathBuf {`
`1460`	`1460`
`1461`	`1461`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1462`	`1462`	`impl fmt::Debug for PathBuf {`
`1463`		`- fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`1463`	`+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {`
`1464`	`1464`	`fmt::Debug::fmt(&**self, formatter)`
`1465`	`1465`	`}`
`1466`	`1466`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,13 +48,13 @@ impl Error {`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`impl fmt::Debug for Error {`
`51`		`- fn fmt(&self, f: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {`
	`51`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`52`	`52`	`f.write_str(self.text())`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`impl fmt::Display for Error {`
`57`		`- fn fmt(&self, f: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {`
	`57`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`58`	`58`	`f.write_str(self.text())`
`59`	`59`	`}`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ pub struct CodePoint {`
`56`	`56`	/// Example: `U+1F4A9`
`57`	`57`	`impl fmt::Debug for CodePoint {`
`58`	`58`	`#[inline]`
`59`		`- fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`59`	`+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {`
`60`	`60`	`write!(formatter, "U+{:04X}", self.value)`
`61`	`61`	`}`
`62`	`62`	`}`
`@@ -144,7 +144,7 @@ impl ops::DerefMut for Wtf8Buf {`
`144`	`144`	/// Example: `"a\u{D800}"` for a string with code points [U+0061, U+D800]
`145`	`145`	`impl fmt::Debug for Wtf8Buf {`
`146`	`146`	`#[inline]`
`147`		`- fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`147`	`+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {`
`148`	`148`	`fmt::Debug::fmt(&**self, formatter)`
`149`	`149`	`}`
`150`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -989,7 +989,7 @@ mod strcursor {`
`989`	`989`	`}`
`990`	`990`
`991`	`991`	`impl<'a> std::fmt::Debug for StrCursor<'a> {`
`992`		`- fn fmt(&self, fmt: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {`
	`992`	`+ fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {`
`993`	`993`	`write!(fmt, "StrCursor({:?} \| {:?})", self.slice_before(), self.slice_after())`
`994`	`994`	`}`
`995`	`995`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ use std::{env, fmt, process, sync, thread};`
`15`	`15`
`16`	`16`	`struct SlowFmt(u32);`
`17`	`17`	`impl fmt::Debug for SlowFmt {`
`18`		`- fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {`
	`18`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`19`	`19`	`thread::sleep_ms(3);`
`20`	`20`	`self.0.fmt(f)`
`21`	`21`	`}`