From c4e31bd968a19cbaeb53761f13840d4b7b77234f Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Thu, 13 Apr 2017 12:43:24 -0700
Subject: [PATCH] Match the associated types from the Serializer trait

---
 serde/src/ser/impossible.rs | 76 ++++++++++++++++++-------------------
 1 file changed, 38 insertions(+), 38 deletions(-)

diff --git a/serde/src/ser/impossible.rs b/serde/src/ser/impossible.rs
index 975c4af1..c90c98f5 100644
--- a/serde/src/ser/impossible.rs
+++ b/serde/src/ser/impossible.rs
@@ -61,133 +61,133 @@ use ser::{self, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct,
 /// [`SerializeMap`]: trait.SerializeMap.html
 /// [`SerializeStruct`]: trait.SerializeStruct.html
 /// [`SerializeStructVariant`]: trait.SerializeStructVariant.html
-pub struct Impossible<Ok, E> {
+pub struct Impossible<Ok, Error> {
     void: Void,
-    _marker: PhantomData<(Ok, E)>,
+    _marker: PhantomData<(Ok, Error)>,
 }
 
 enum Void {}
 
-impl<Ok, E> SerializeSeq for Impossible<Ok, E>
+impl<Ok, Error> SerializeSeq for Impossible<Ok, Error>
 where
-    E: ser::Error,
+    Error: ser::Error,
 {
     type Ok = Ok;
-    type Error = E;
+    type Error = Error;
 
-    fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
+    fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), Error> {
         match self.void {}
     }
 
-    fn end(self) -> Result<Ok, E> {
+    fn end(self) -> Result<Ok, Error> {
         match self.void {}
     }
 }
 
-impl<Ok, E> SerializeTuple for Impossible<Ok, E>
+impl<Ok, Error> SerializeTuple for Impossible<Ok, Error>
 where
-    E: ser::Error,
+    Error: ser::Error,
 {
     type Ok = Ok;
-    type Error = E;
+    type Error = Error;
 
-    fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
+    fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), Error> {
         match self.void {}
     }
 
-    fn end(self) -> Result<Ok, E> {
+    fn end(self) -> Result<Ok, Error> {
         match self.void {}
     }
 }
 
-impl<Ok, E> SerializeTupleStruct for Impossible<Ok, E>
+impl<Ok, Error> SerializeTupleStruct for Impossible<Ok, Error>
 where
-    E: ser::Error,
+    Error: ser::Error,
 {
     type Ok = Ok;
-    type Error = E;
+    type Error = Error;
 
-    fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
+    fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), Error> {
         match self.void {}
     }
 
-    fn end(self) -> Result<Ok, E> {
+    fn end(self) -> Result<Ok, Error> {
         match self.void {}
     }
 }
 
-impl<Ok, E> SerializeTupleVariant for Impossible<Ok, E>
+impl<Ok, Error> SerializeTupleVariant for Impossible<Ok, Error>
 where
-    E: ser::Error,
+    Error: ser::Error,
 {
     type Ok = Ok;
-    type Error = E;
+    type Error = Error;
 
-    fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
+    fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), Error> {
         match self.void {}
     }
 
-    fn end(self) -> Result<Ok, E> {
+    fn end(self) -> Result<Ok, Error> {
         match self.void {}
     }
 }
 
-impl<Ok, E> SerializeMap for Impossible<Ok, E>
+impl<Ok, Error> SerializeMap for Impossible<Ok, Error>
 where
-    E: ser::Error,
+    Error: ser::Error,
 {
     type Ok = Ok;
-    type Error = E;
+    type Error = Error;
 
-    fn serialize_key<T: ?Sized + Serialize>(&mut self, _key: &T) -> Result<(), E> {
+    fn serialize_key<T: ?Sized + Serialize>(&mut self, _key: &T) -> Result<(), Error> {
         match self.void {}
     }
 
-    fn serialize_value<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
+    fn serialize_value<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), Error> {
         match self.void {}
     }
 
-    fn end(self) -> Result<Ok, E> {
+    fn end(self) -> Result<Ok, Error> {
         match self.void {}
     }
 }
 
-impl<Ok, E> SerializeStruct for Impossible<Ok, E>
+impl<Ok, Error> SerializeStruct for Impossible<Ok, Error>
 where
-    E: ser::Error,
+    Error: ser::Error,
 {
     type Ok = Ok;
-    type Error = E;
+    type Error = Error;
 
     fn serialize_field<T: ?Sized + Serialize>(
         &mut self,
         _key: &'static str,
         _value: &T,
-    ) -> Result<(), E> {
+    ) -> Result<(), Error> {
         match self.void {}
     }
 
-    fn end(self) -> Result<Ok, E> {
+    fn end(self) -> Result<Ok, Error> {
         match self.void {}
     }
 }
 
-impl<Ok, E> SerializeStructVariant for Impossible<Ok, E>
+impl<Ok, Error> SerializeStructVariant for Impossible<Ok, Error>
 where
-    E: ser::Error,
+    Error: ser::Error,
 {
     type Ok = Ok;
-    type Error = E;
+    type Error = Error;
 
     fn serialize_field<T: ?Sized + Serialize>(
         &mut self,
         _key: &'static str,
         _value: &T,
-    ) -> Result<(), E> {
+    ) -> Result<(), Error> {
         match self.void {}
     }
 
-    fn end(self) -> Result<Ok, E> {
+    fn end(self) -> Result<Ok, Error> {
         match self.void {}
     }
 }