diff --git a/serde_codegen/src/attr.rs b/serde_codegen/src/attr.rs
index c9ff9e80..72832d06 100644
--- a/serde_codegen/src/attr.rs
+++ b/serde_codegen/src/attr.rs
@@ -563,37 +563,37 @@ fn wrap_serialize_with(cx: &ExtCtxt,
 
     quote_expr!(cx, {
         trait __SerdeSerializeWith {
-            fn __serde_serialize_with<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-                where S: _serde::ser::Serializer;
+            fn __serde_serialize_with<__S>(&self, serializer: &mut __S) -> Result<(), __S::Error>
+                where __S: _serde::ser::Serializer;
         }
 
-        impl<'a, T> __SerdeSerializeWith for &'a T
-            where T: 'a + __SerdeSerializeWith,
+        impl<'__a, __T> __SerdeSerializeWith for &'__a __T
+            where __T: '__a + __SerdeSerializeWith,
         {
-            fn __serde_serialize_with<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-                where S: _serde::ser::Serializer
+            fn __serde_serialize_with<__S>(&self, serializer: &mut __S) -> Result<(), __S::Error>
+                where __S: _serde::ser::Serializer
             {
                 (**self).__serde_serialize_with(serializer)
             }
         }
 
         impl $generics __SerdeSerializeWith for $container_ty $where_clause {
-            fn __serde_serialize_with<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-                where S: _serde::ser::Serializer
+            fn __serde_serialize_with<__S>(&self, serializer: &mut __S) -> Result<(), __S::Error>
+                where __S: _serde::ser::Serializer
             {
                 $expr
             }
         }
 
-        struct __SerdeSerializeWithStruct<'a, T: 'a> {
-            value: &'a T,
+        struct __SerdeSerializeWithStruct<'__a, __T: '__a> {
+            value: &'__a __T,
         }
 
-        impl<'a, T> _serde::ser::Serialize for __SerdeSerializeWithStruct<'a, T>
-            where T: 'a + __SerdeSerializeWith
+        impl<'__a, __T> _serde::ser::Serialize for __SerdeSerializeWithStruct<'__a, __T>
+            where __T: '__a + __SerdeSerializeWith
         {
-            fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-                where S: _serde::ser::Serializer
+            fn serialize<__S>(&self, serializer: &mut __S) -> Result<(), __S::Error>
+                where __S: _serde::ser::Serializer
             {
                 self.value.__serde_serialize_with(serializer)
             }
diff --git a/serde_codegen/src/de.rs b/serde_codegen/src/de.rs
index f98fe765..bd7ad923 100644
--- a/serde_codegen/src/de.rs
+++ b/serde_codegen/src/de.rs
@@ -356,15 +356,15 @@ fn deserialize_unit_struct(
             type Value = $type_ident;
 
             #[inline]
-            fn visit_unit<E>(&mut self) -> ::std::result::Result<$type_ident, E>
-                where E: _serde::de::Error,
+            fn visit_unit<__E>(&mut self) -> ::std::result::Result<$type_ident, __E>
+                where __E: _serde::de::Error,
             {
                 Ok($type_ident)
             }
 
             #[inline]
-            fn visit_seq<V>(&mut self, mut visitor: V) -> ::std::result::Result<$type_ident, V::Error>
-                where V: _serde::de::SeqVisitor,
+            fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$type_ident, __V::Error>
+                where __V: _serde::de::SeqVisitor,
             {
                 try!(visitor.end());
                 self.visit_unit()
@@ -408,8 +408,8 @@ fn deserialize_newtype_struct(
             type Value = $ty;
 
             #[inline]
-            fn visit_newtype_struct<D>(&mut self, deserializer: &mut D) -> ::std::result::Result<Self::Value, D::Error>
-                where D: _serde::de::Deserializer,
+            fn visit_newtype_struct<__E>(&mut self, deserializer: &mut __E) -> ::std::result::Result<Self::Value, __E::Error>
+                where __E: _serde::de::Deserializer,
             {
                 let value = try!(_serde::de::Deserialize::deserialize(deserializer));
                 Ok($type_ident(value))
@@ -1032,11 +1032,11 @@ fn deserialize_field_visitor(
     let impl_item = quote_item!(cx,
         impl _serde::de::Deserialize for __Field {
             #[inline]
-            fn deserialize<D>(deserializer: &mut D) -> ::std::result::Result<__Field, D::Error>
-                where D: _serde::de::Deserializer,
+            fn deserialize<__D>(deserializer: &mut __D) -> ::std::result::Result<__Field, __D::Error>
+                where __D: _serde::de::Deserializer,
             {
-                struct __FieldVisitor<D> {
-                    phantom: ::std::marker::PhantomData<D>
+                struct __FieldVisitor<__D> {
+                    phantom: ::std::marker::PhantomData<__D>
                 }
 
                 impl<__D> _serde::de::Visitor for __FieldVisitor<__D>
@@ -1044,27 +1044,27 @@ fn deserialize_field_visitor(
                 {
                     type Value = __Field;
 
-                    fn visit_usize<E>(&mut self, value: usize) -> ::std::result::Result<__Field, E>
-                        where E: _serde::de::Error,
+                    fn visit_usize<__E>(&mut self, value: usize) -> ::std::result::Result<__Field, __E>
+                        where __E: _serde::de::Error,
                     {
                         $index_body
                     }
 
-                    fn visit_str<E>(&mut self, value: &str) -> ::std::result::Result<__Field, E>
-                        where E: _serde::de::Error,
+                    fn visit_str<__E>(&mut self, value: &str) -> ::std::result::Result<__Field, __E>
+                        where __E: _serde::de::Error,
                     {
                         $str_body
                     }
 
-                    fn visit_bytes<E>(&mut self, value: &[u8]) -> ::std::result::Result<__Field, E>
-                        where E: _serde::de::Error,
+                    fn visit_bytes<__E>(&mut self, value: &[u8]) -> ::std::result::Result<__Field, __E>
+                        where __E: _serde::de::Error,
                     {
                         $bytes_body
                     }
                 }
 
                 deserializer.deserialize_struct_field(
-                    __FieldVisitor::<D>{
+                    __FieldVisitor::<__D>{
                         phantom: ::std::marker::PhantomData
                     }
                 )
@@ -1309,8 +1309,8 @@ fn wrap_deserialize_with(
         ).unwrap(),
         quote_stmt!(cx,
             impl $impl_generics _serde::de::Deserialize for $wrapper_ty $where_clause {
-                fn deserialize<D>(__d: &mut D) -> ::std::result::Result<Self, D::Error>
-                    where D: _serde::de::Deserializer
+                fn deserialize<__D>(__d: &mut __D) -> ::std::result::Result<Self, __D::Error>
+                    where __D: _serde::de::Deserializer
                 {
                     let value = try!($deserialize_with(__d));
                     Ok(__SerdeDeserializeWithStruct {
diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs
index ac4702c9..dcae12d0 100644
--- a/serde_codegen/src/ser.rs
+++ b/serde_codegen/src/ser.rs
@@ -658,8 +658,8 @@ fn serialize_tuple_struct_visitor(
             for Visitor $visitor_generics
             $where_clause {
                 #[inline]
-                fn visit<S>(&mut self, _serializer: &mut S) -> ::std::result::Result<Option<()>, S::Error>
-                    where S: _serde::ser::Serializer
+                fn visit<__S>(&mut self, _serializer: &mut __S) -> ::std::result::Result<Option<()>, __S::Error>
+                    where __S: _serde::ser::Serializer
                 {
                     match self.state {
                         $arms
@@ -763,8 +763,8 @@ fn serialize_struct_visitor(
             for Visitor $visitor_generics
             $where_clause {
                 #[inline]
-                fn visit<S>(&mut self, _serializer: &mut S) -> ::std::result::Result<Option<()>, S::Error>
-                    where S: _serde::ser::Serializer,
+                fn visit<__S>(&mut self, _serializer: &mut __S) -> ::std::result::Result<Option<()>, __S::Error>
+                    where __S: _serde::ser::Serializer,
                 {
                     loop {
                         match self.state {