diff --git a/derives/src/de.rs b/derives/src/de.rs
index b7541cf..87dde33 100644
--- a/derives/src/de.rs
+++ b/derives/src/de.rs
@@ -25,7 +25,7 @@ pub fn get_de_enum_impl_block(container: Container) -> proc_macro2::TokenStream
                 if let Some(ty) = ty {
                     quote! {
                         #name => {
-                            let _r = #ty::deserialize(#name, reader, $attrs, $b);
+                            let _r = #ty::deserialize(#name, _reader_, $attrs, $b);
                             return Self::#ident(_r);
                         }
                     }
@@ -76,26 +76,26 @@ pub fn get_de_enum_impl_block(container: Container) -> proc_macro2::TokenStream
             let name = v.name.as_ref().expect("should have `name` for `child`");
             quote! {#name}
         });
-    let exact_tags = children_branches!(attrs, is_empty);
+    let exact_tags = children_branches!(_attrs_, _is_empty_);
     quote! {
         #[allow(unused_assignments)]
         impl #impl_generics ::xmlserde::XmlDeserialize for #ident #type_generics #where_clause {
             fn deserialize<B: std::io::BufRead>(
-                tag: &[u8],
-                reader: &mut ::xmlserde::quick_xml::Reader<B>,
-                attrs: ::xmlserde::quick_xml::events::attributes::Attributes,
-                is_empty: bool,
+                _tag_: &[u8],
+                _reader_: &mut ::xmlserde::quick_xml::Reader<B>,
+                _attrs_: ::xmlserde::quick_xml::events::attributes::Attributes,
+                _is_empty_: bool,
             ) -> Self {
                 use ::xmlserde::quick_xml::events::*;
-                match tag {
+                match _tag_ {
                     #(#exact_tags)*
                     _ => {},
                 }
                 let mut buf = Vec::<u8>::new();
                 let mut result = Option::<Self>::None;
                 loop {
-                    match reader.read_event_into(&mut buf) {
-                        Ok(Event::End(e)) if e.name().into_inner() == tag => {
+                    match _reader_.read_event_into(&mut buf) {
+                        Ok(Event::End(e)) if e.name().into_inner() == _tag_ => {
                             break
                         },
                         Ok(Event::Start(_s)) => match _s.name().into_inner() {
@@ -217,13 +217,13 @@ pub fn get_de_struct_impl_block(container: Container) -> proc_macro2::TokenStrea
         #[allow(unused_assignments)]
         impl #impl_generics ::xmlserde::XmlDeserialize for #ident #type_generics #where_clause {
             fn deserialize<B: std::io::BufRead>(
-                tag: &[u8],
-                reader: &mut ::xmlserde::quick_xml::Reader<B>,
-                attrs: ::xmlserde::quick_xml::events::attributes::Attributes,
-                is_empty: bool,
+                _tag_: &[u8],
+                _reader_: &mut ::xmlserde::quick_xml::Reader<B>,
+                _attrs_: ::xmlserde::quick_xml::events::attributes::Attributes,
+                _is_empty_: bool,
             ) -> Self {
                 #fields_init
-                attrs.into_iter().for_each(|attr| {
+                _attrs_.into_iter().for_each(|attr| {
                     if let Ok(attr) = attr {
                         match attr.key.into_inner() {
                             #(#attr_branches)*
@@ -237,17 +237,19 @@ pub fn get_de_struct_impl_block(container: Container) -> proc_macro2::TokenStrea
                 let mut buf = Vec::<u8>::new();
                 use ::xmlserde::quick_xml::events::Event;
                 #vec_init
-                if is_empty {} else {
+                if _is_empty_ {} else {
                     loop {
-                        match reader.read_event_into(&mut buf) {
-                            Ok(Event::End(e)) if e.name().into_inner() == tag => {
+                        match _reader_.read_event_into(&mut buf) {
+                            Ok(Event::End(e)) if e.name().into_inner() == _tag_ => {
                                 break
                             },
                             #sfc_branch
                             #child_branches
                             #text_branch
                             #encounter_unknown_branch
-                            Ok(Event::Eof) => break,
+                            Ok(Event::Eof) => {
+                                break;
+                            },
                             Err(_) => break,
                             _ => {},
                         }
@@ -693,17 +695,17 @@ fn untag_enums_match_branch(fields: &[StructField]) -> proc_macro2::TokenStream
         let branch = match f.generic {
             Generic::Vec(ty) => quote! {
                 _ty if #ty::__get_children_tags().contains(&_ty) => {
-                    #ident.push(#ty::deserialize(_ty, reader, s.attributes(), is_empty));
+                    #ident.push(#ty::deserialize(_ty, _reader_, s.attributes(), _is_empty_));
                 }
             },
             Generic::Opt(ty) => quote! {
                 _ty if #ty::__get_children_tags().contains(&_ty) => {
-                    #ident = Some(#ty::deserialize(_ty, reader, s.attributes(), is_empty));
+                    #ident = Some(#ty::deserialize(_ty, _reader_, s.attributes(), _is_empty_));
                 }
             },
             Generic::None => quote! {
                 _t if #ty::__get_children_tags().contains(&_t) => {
-                    #ident = Some(#ty::deserialize(_t, reader, s.attributes(), is_empty));
+                    #ident = Some(#ty::deserialize(_t, _reader_, s.attributes(), _is_empty_));
                 }
             },
         };
@@ -730,7 +732,7 @@ fn untag_structs_match_branch(fields: &[StructField]) -> proc_macro2::TokenStrea
             Generic::Vec(_) => unreachable!(),
             Generic::Opt(t) => quote! {
                 _t if #t::__get_children_tags().contains(&_t) => {
-                    let _r = ::xmlserde::Unparsed::deserialize(_t, reader, s.attributes(), is_empty);
+                    let _r = ::xmlserde::Unparsed::deserialize(_t, _reader_, s.attributes(), _is_empty_);
                     let _tags = #t::__get_children_tags();
                     let idx = _tags.binary_search(&_t).unwrap();
                     #ident_opt_unparsed_array.push((_tags[idx], _r));
@@ -738,7 +740,7 @@ fn untag_structs_match_branch(fields: &[StructField]) -> proc_macro2::TokenStrea
             },
             Generic::None => quote! {
                 _t if #ty::__get_children_tags().contains(&_t) => {
-                    let _r = ::xmlserde::Unparsed::deserialize(_t, reader, s.attributes(), is_empty);
+                    let _r = ::xmlserde::Unparsed::deserialize(_t, _reader_, s.attributes(), _is_empty_);
                     let _tags = #ty::__get_children_tags();
                     let idx = _tags.binary_search(&_t).unwrap();
                     #ident_unparsed_array.push((_tags[idx], _r));
@@ -772,7 +774,7 @@ fn children_match_branch(
             Generic::Vec(vec_ty) => {
                 quote! {
                     #tag => {
-                        let __ele = #vec_ty::deserialize(#tag, reader, s.attributes(), is_empty);
+                        let __ele = #vec_ty::deserialize(#tag, _reader_, s.attributes(), _is_empty_);
                         #ident.push(__ele);
                     }
                 }
@@ -780,7 +782,7 @@ fn children_match_branch(
             Generic::Opt(opt_ty) => {
                 quote! {
                     #tag => {
-                        let __f = #opt_ty::deserialize(#tag, reader, s.attributes(), is_empty);
+                        let __f = #opt_ty::deserialize(#tag, _reader_, s.attributes(), _is_empty_);
                         #ident = Some(__f);
                     },
                 }
@@ -797,7 +799,7 @@ fn children_match_branch(
                 };
                 quote! {
                     #tag => {
-                        let __f = #t::deserialize(#tag, reader, s.attributes(), is_empty);
+                        let __f = #t::deserialize(#tag, _reader_, s.attributes(), _is_empty_);
                         #tt
                     },
                 }
@@ -811,7 +813,7 @@ fn children_match_branch(
 
     quote! {
         Ok(Event::Empty(s)) => {
-            let is_empty = true;
+            let _is_empty_ = true;
             match s.name().into_inner() {
                 #(#branches)*
                 #untagged_enums_branches
@@ -820,7 +822,7 @@ fn children_match_branch(
             }
         }
         Ok(Event::Start(s)) => {
-            let is_empty = false;
+            let _is_empty_ = false;
             match s.name().into_inner() {
                 #(#branches)*
                 #untagged_enums_branches
diff --git a/derives/src/ser.rs b/derives/src/ser.rs
index e8444a1..c090496 100644
--- a/derives/src/ser.rs
+++ b/derives/src/ser.rs
@@ -22,14 +22,14 @@ fn get_ser_enum_impl_block(container: Container) -> proc_macro2::TokenStream {
             let name = v.name.as_ref().expect("should have name");
             quote!{
                 Self::#f => {
-                    if tag == b"" {
+                    if _tag_ == b"" {
                         let _t = String::from_utf8_lossy(#name);
-                        let _ = writer.write_event(Event::Empty(BytesStart::new(_t)));
+                        let _ = _writer_.write_event(Event::Empty(BytesStart::new(_t)));
                     } else {
-                        let _ = writer.write_event(Event::Start(BytesStart::new(String::from_utf8_lossy(tag))));
+                        let _ = _writer_.write_event(Event::Start(BytesStart::new(String::from_utf8_lossy(_tag_))));
                         let _t = String::from_utf8_lossy(#name);
-                        let _ = writer.write_event(Event::Empty(BytesStart::new(_t)));
-                        let _ = writer.write_event(Event::End(BytesEnd::new(String::from_utf8_lossy(tag))));
+                        let _ = _writer_.write_event(Event::Empty(BytesStart::new(_t)));
+                        let _ = _writer_.write_event(Event::End(BytesEnd::new(String::from_utf8_lossy(_tag_))));
                     }
                 }
             }
@@ -37,19 +37,19 @@ fn get_ser_enum_impl_block(container: Container) -> proc_macro2::TokenStream {
             if matches!(ele_ty, EleType::Text) {
                 quote!{
                     Self::#f(c) => {
-                        let _ = writer.write_event(Event::Text(BytesText::new(&c.serialize())));
+                        let _ = _writer_.write_event(Event::Text(BytesText::new(&c.serialize())));
                     }
                 }
             } else {
                 let name = v.name.as_ref().expect("should have hame");
                 quote! {
                     Self::#f(c) => {
-                        if tag == b"" {
-                            c.serialize(#name, writer);
+                        if _tag_ == b"" {
+                            c.serialize(#name, _writer_);
                         } else {
-                            let _ = writer.write_event(Event::Start(BytesStart::new(String::from_utf8_lossy(tag))));
-                            c.serialize(#name, writer);
-                            let _ = writer.write_event(Event::End(BytesEnd::new(String::from_utf8_lossy(tag))));
+                            let _ = _writer_.write_event(Event::Start(BytesStart::new(String::from_utf8_lossy(_tag_))));
+                            c.serialize(#name, _writer_);
+                            let _ = _writer_.write_event(Event::End(BytesEnd::new(String::from_utf8_lossy(_tag_))));
                         }
                     },
                 }
@@ -61,8 +61,8 @@ fn get_ser_enum_impl_block(container: Container) -> proc_macro2::TokenStream {
         impl #impl_generics ::xmlserde::XmlSerialize for #ident #type_generics #where_clause {
             fn serialize<W: std::io::Write>(
                 &self,
-                tag: &[u8],
-                writer: &mut ::xmlserde::quick_xml::Writer<W>,
+                _tag_: &[u8],
+                _writer_: &mut ::xmlserde::quick_xml::Writer<W>,
             ) {
                 use ::xmlserde::quick_xml::events::*;
                 match self {
@@ -76,7 +76,7 @@ fn get_ser_enum_impl_block(container: Container) -> proc_macro2::TokenStream {
 fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
     let write_ns = match container.with_ns {
         Some(ns) => quote! {
-            attrs.push(Attribute::from((b"xmlns".as_ref(), #ns.as_ref())));
+            _attrs_.push(Attribute::from((b"xmlns".as_ref(), #ns.as_ref())));
         },
         None => quote! {},
     };
@@ -87,7 +87,7 @@ fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
             quote! {
                 let mut __vec = b"xmlns:".to_vec();
                 __vec.extend(#ns.to_vec());
-                attrs.push(Attribute::from((__vec.as_ref(), #value.as_ref())));
+                _attrs_.push(Attribute::from((__vec.as_ref(), #value.as_ref())));
             }
         });
         quote! {#(#cns)*}
@@ -116,7 +116,7 @@ fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
                     match &self.#ident {
                         Some(v) => {
                             sr = v.serialize();
-                            attrs.push(Attribute::from((#name.as_ref(), sr.as_bytes())));
+                            _attrs_.push(Attribute::from((#name.as_ref(), sr.as_bytes())));
                         },
                         None => {},
                     }
@@ -127,12 +127,12 @@ fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
                     let mut ser;
                     if #path() != self.#ident {
                         ser = self.#ident.serialize();
-                        attrs.push(Attribute::from((#name.as_ref(), ser.as_bytes())));
+                        _attrs_.push(Attribute::from((#name.as_ref(), ser.as_bytes())));
                     }
                 },
                 None => quote! {
                     let ser = self.#ident.serialize();
-                    attrs.push(Attribute::from((#name.as_ref(), ser.as_bytes())));
+                    _attrs_.push(Attribute::from((#name.as_ref(), ser.as_bytes())));
                 },
             },
         }
@@ -146,7 +146,7 @@ fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
                     Some(__d) => {
                         let r = __d.serialize();
                         let event = BytesText::new(&r);
-                        writer.write_event(Event::Text(event));
+                        _writer_.write_event(Event::Text(event));
                     }
                 }
             }
@@ -154,7 +154,7 @@ fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
             quote! {
                 let r = self.#ident.serialize();
                 let event = BytesText::new(&r);
-                writer.write_event(Event::Text(event));
+                _writer_.write_event(Event::Text(event));
             }
         }
     } else {
@@ -164,7 +164,7 @@ fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
             quote! {
                 if self.#ident {
                     let event = BytesStart::new(String::from_utf8_lossy(#name));
-                    writer.write_event(Event::Empty(event));
+                    _writer_.write_event(Event::Empty(event));
                 }
             }
         });
@@ -175,14 +175,14 @@ fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
                 let ident = f.original.ident.as_ref().unwrap();
                 let name = f.name.as_ref().expect("should have name");
                 quote! {
-                    self.#ident.serialize(#name, writer);
+                    self.#ident.serialize(#name, _writer_);
                 }
             }
         });
         let write_untags = untags.into_iter().map(|f| {
             let ident = f.original.ident.as_ref().expect("should have name");
             quote! {
-                self.#ident.serialize(b"", writer);
+                self.#ident.serialize(b"", _writer_);
             }
         });
         quote! {
@@ -195,15 +195,15 @@ fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
     let (impl_generics, type_generics, where_clause) = container.original.generics.split_for_impl();
     let write_event = quote! {
         if is_empty {
-            writer.write_event(Event::Empty(start));
-        } else if is_untagged {
+            _writer_.write_event(Event::Empty(start));
+        } else if _is_untagged_ {
             // Not to write the start event
             #write_text_or_children
         } else {
-            writer.write_event(Event::Start(start));
+            _writer_.write_event(Event::Start(start));
             #write_text_or_children
-            let end = BytesEnd::new(String::from_utf8_lossy(tag));
-            writer.write_event(Event::End(end));
+            let end = BytesEnd::new(String::from_utf8_lossy(_tag_));
+            _writer_.write_event(Event::End(end));
         }
     };
     let get_root = if let Some(r) = &container.root {
@@ -220,19 +220,19 @@ fn get_ser_struct_impl_block(container: Container) -> proc_macro2::TokenStream {
         impl #impl_generics ::xmlserde::XmlSerialize for #ident #type_generics #where_clause {
             fn serialize<W: std::io::Write>(
                 &self,
-                tag: &[u8],
-                writer: &mut ::xmlserde::quick_xml::Writer<W>,
+                _tag_: &[u8],
+                _writer_: &mut ::xmlserde::quick_xml::Writer<W>,
             ) {
                 use ::xmlserde::quick_xml::events::*;
                 use ::xmlserde::quick_xml::events::attributes::Attribute;
                 use ::xmlserde::XmlValue;
-                let start = BytesStart::new(String::from_utf8_lossy(tag));
-                let mut attrs = Vec::<Attribute>::new();
-                let is_untagged = tag.len() == 0;
+                let start = BytesStart::new(String::from_utf8_lossy(_tag_));
+                let mut _attrs_ = Vec::<Attribute>::new();
+                let _is_untagged_ = _tag_.len() == 0;
                 #write_ns
                 #write_custom_ns
                 #(#build_attr_and_push)*
-                let start = start.with_attributes(attrs);
+                let start = start.with_attributes(_attrs_);
                 #init
                 #write_event
             }
diff --git a/src/lib.rs b/src/lib.rs
index f295b11..efa7620 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -176,9 +176,9 @@ impl<T: XmlSerialize> XmlSerialize for Option<T> {
 }
 
 impl<T: XmlSerialize> XmlSerialize for Vec<T> {
-    fn serialize<W: Write>(&self, tag: &[u8], writer: &mut quick_xml::Writer<W>) {
+    fn serialize<W: Write>(&self, _tag_: &[u8], _writer_: &mut quick_xml::Writer<W>) {
         self.iter().for_each(|c| {
-            let _ = c.serialize(tag, writer);
+            let _ = c.serialize(_tag_, _writer_);
         });
     }
 }
@@ -252,38 +252,38 @@ pub struct Unparsed {
 }
 
 impl XmlSerialize for Unparsed {
-    fn serialize<W: Write>(&self, tag: &[u8], writer: &mut quick_xml::Writer<W>) {
+    fn serialize<W: Write>(&self, _tag_: &[u8], _writer_: &mut quick_xml::Writer<W>) {
         use quick_xml::events::*;
-        let mut start = BytesStart::new(String::from_utf8_lossy(tag));
+        let mut start = BytesStart::new(String::from_utf8_lossy(_tag_));
         self.attrs.iter().for_each(|(k, v)| {
             let k = k as &str;
             let v = v as &str;
             start.push_attribute((k, v));
         });
         if self.data.len() > 0 {
-            let _ = writer.write_event(Event::Start(start));
+            let _ = _writer_.write_event(Event::Start(start));
             self.data.iter().for_each(|e| {
-                let _ = writer.write_event(e.clone());
+                let _ = _writer_.write_event(e.clone());
             });
-            let _ = writer.write_event(Event::End(BytesEnd::new(String::from_utf8_lossy(tag))));
+            let _ = _writer_.write_event(Event::End(BytesEnd::new(String::from_utf8_lossy(_tag_))));
         } else {
-            let _ = writer.write_event(Event::Empty(start));
+            let _ = _writer_.write_event(Event::Empty(start));
         }
     }
 }
 
 impl XmlDeserialize for Unparsed {
     fn deserialize<B: BufRead>(
-        tag: &[u8],
-        reader: &mut quick_xml::Reader<B>,
-        attrs: quick_xml::events::attributes::Attributes,
-        is_empty: bool,
+        _tag_: &[u8],
+        _reader_: &mut quick_xml::Reader<B>,
+        _attrs_: quick_xml::events::attributes::Attributes,
+        _is_empty_: bool,
     ) -> Self {
         use quick_xml::events::*;
         let mut attrs_vec = Vec::<(String, String)>::new();
         let mut data = Vec::<Event<'static>>::new();
         let mut buf = Vec::<u8>::new();
-        attrs.into_iter().for_each(|a| {
+        _attrs_.into_iter().for_each(|a| {
             if let Ok(attr) = a {
                 let key =
                     String::from_utf8(attr.key.into_inner().to_vec()).unwrap_or(String::from(""));
@@ -291,15 +291,15 @@ impl XmlDeserialize for Unparsed {
                 attrs_vec.push((key, value))
             }
         });
-        if is_empty {
+        if _is_empty_ {
             return Unparsed {
                 data,
                 attrs: attrs_vec,
             };
         }
         loop {
-            match reader.read_event_into(&mut buf) {
-                Ok(Event::End(e)) if e.name().into_inner() == tag => break,
+            match _reader_.read_event_into(&mut buf) {
+                Ok(Event::End(e)) if e.name().into_inner() == _tag_ => break,
                 Ok(Event::Eof) => break,
                 Err(_) => break,
                 Ok(e) => data.push(e.into_owned()),
diff --git a/tests/lib.rs b/tests/lib.rs
index a2da7a4..1709278 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -23,14 +23,14 @@ mod tests {
 
     #[test]
     fn default_for_child() {
-        #[derive(XmlDeserialize, Default)]
+        #[derive(Debug, XmlDeserialize, Default)]
         #[xmlserde(root = b"property")]
         struct Property {
             #[xmlserde(name = b"name", ty = "attr")]
             name: String,
         }
 
-        #[derive(XmlDeserialize, Default)]
+        #[derive(Debug, XmlDeserialize, Default)]
         #[xmlserde(root = b"properties")]
         struct InnerProperties {
             #[xmlserde(name = b"property", ty = "child")]
@@ -102,7 +102,7 @@ mod tests {
 
     #[test]
     fn derive_deserialize_vec_with_init_size_from_attr() {
-        #[derive(XmlDeserialize, Default)]
+        #[derive(Debug, XmlDeserialize, Default)]
         pub struct Child {
             #[xmlserde(name = b"age", ty = "attr")]
             pub age: u16,
@@ -112,7 +112,7 @@ mod tests {
         fn default_zero() -> u32 {
             0
         }
-        #[derive(XmlDeserialize, Default)]
+        #[derive(Debug, XmlDeserialize, Default)]
         #[xmlserde(root = b"root")]
         pub struct Aa {
             #[xmlserde(name = b"f", ty = "child", vec_size = "cnt")]
@@ -143,7 +143,7 @@ mod tests {
 
     #[test]
     fn derive_deserialize_vec_with_init_size() {
-        #[derive(XmlDeserialize, Default)]
+        #[derive(Debug, XmlDeserialize, Default)]
         pub struct Child {
             #[xmlserde(name = b"age", ty = "attr")]
             pub _age: u16,
@@ -153,7 +153,7 @@ mod tests {
         fn default_zero() -> u32 {
             0
         }
-        #[derive(XmlDeserialize, Default)]
+        #[derive(Debug, XmlDeserialize, Default)]
         #[xmlserde(root = b"root")]
         pub struct Aa {
             #[xmlserde(name = b"f", ty = "child", vec_size = 10)]