diff --git a/src/attr.rs b/src/attr.rs
index 74ed01f..4625fc6 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -46,7 +46,7 @@
                 let tokens = ts.clone().into_iter().collect::<Vec<_>>();
                 if let Some(nested_meta_items) = list_of_nested_meta_items_from_tokens(&tokens) {
                     return Some(MetaItem::List(MetaItemList {
-                        paren_token: tokens::Paren(Span(self.tts[0].0.span)),
+                        paren_token: tokens::Paren(self.tts[0].0.span),
                         ident: *name,
                         nested: nested_meta_items,
                     }));
@@ -59,10 +59,10 @@
                 if let TokenNode::Literal(ref lit) = self.tts[1].0.kind {
                     return Some(MetaItem::NameValue(MetaNameValue {
                         ident: *name,
-                        eq_token: Token![=]([Span(self.tts[0].0.span)]),
+                        eq_token: Token![=]([self.tts[0].0.span]),
                         lit: Lit {
                             value: LitKind::Other(lit.clone()),
-                            span: Span(self.tts[1].0.span),
+                            span: self.tts[1].0.span,
                         },
                     }));
                 }
@@ -82,22 +82,22 @@
         TokenNode::Literal(ref lit) => {
             let lit = Lit {
                 value: LitKind::Other(lit.clone()),
-                span: Span(tts[0].span),
+                span: tts[0].span,
             };
             Some((NestedMetaItem::Literal(lit), &tts[1..]))
         }
 
         TokenNode::Term(sym) => {
-            let ident = Ident::new(sym, Span(tts[0].span));
+            let ident = Ident::new(sym, tts[0].span);
             if tts.len() >= 3 {
                 if let TokenNode::Op('=', Spacing::Alone) = tts[1].kind {
                     if let TokenNode::Literal(ref lit) = tts[2].kind {
                         let pair = MetaNameValue {
-                            ident: Ident::new(sym, Span(tts[0].span)),
-                            eq_token: Token![=]([Span(tts[1].span)]),
+                            ident: Ident::new(sym, tts[0].span),
+                            eq_token: Token![=]([tts[1].span]),
                             lit: Lit {
                                 value: LitKind::Other(lit.clone()),
-                                span: Span(tts[2].span),
+                                span: tts[2].span,
                             },
                         };
                         return Some((MetaItem::NameValue(pair).into(), &tts[3..]));
@@ -112,7 +112,7 @@
                         Some(nested_meta_items) => {
                             let list = MetaItemList {
                                 ident: ident,
-                                paren_token: tokens::Paren(Span(tts[1].span)),
+                                paren_token: tokens::Paren(tts[1].span),
                                 nested: nested_meta_items,
                             };
                             Some((MetaItem::List(list).into(), &tts[2..]))
@@ -141,7 +141,7 @@
             first = false;
             None
         } else if let TokenNode::Op(',', Spacing::Alone) = tts[0].kind {
-            let tok = Token![,]([Span(tts[0].span)]);
+            let tok = Token![,]([tts[0].span]);
             tts = &tts[1..];
             if tts.is_empty() {
                 break
diff --git a/src/expr.rs b/src/expr.rs
index a0505a4..dbf6ea0 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -659,7 +659,7 @@
     use ty::parsing::qpath;
 
     #[cfg(feature = "full")]
-    use proc_macro2::{TokenStream, TokenNode, Delimiter, Term};
+    use proc_macro2::{Span, TokenStream, TokenNode, Delimiter, Term};
     use synom::Synom;
     use cursor::Cursor;
     #[cfg(feature = "full")]
@@ -1848,7 +1848,7 @@
                 path: what,
                 bang_token: bang,
                 tokens: vec![TokenTree(proc_macro2::TokenTree {
-                    span: ((data.1).0).0,
+                    span: (data.1).0,
                     kind: TokenNode::Group(Delimiter::Brace, data.0),
                 })],
             },
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 9fc80a7..0d944e6 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -10,6 +10,7 @@
 
 use *;
 use delimited::Delimited;
+use proc_macro2::Span;
 
 trait FoldHelper {
     type Item;
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index a478b64..a688f33 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -9,6 +9,7 @@
 #![cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
 
 use *;
+use proc_macro2::Span;
 
 
 #[cfg(feature = "full")]
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 6d7e616..2ad540d 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -9,6 +9,7 @@
 #![cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
 
 use *;
+use proc_macro2::Span;
 
 
 #[cfg(feature = "full")]
diff --git a/src/ident.rs b/src/ident.rs
index 2555a72..0c51209 100644
--- a/src/ident.rs
+++ b/src/ident.rs
@@ -6,7 +6,7 @@
 use proc_macro2::Term;
 use unicode_xid::UnicodeXID;
 
-use Span;
+use proc_macro2::Span;
 
 /// A word of Rust code, such as a keyword or variable name.
 ///
@@ -252,7 +252,7 @@
             }
 
             Ok((rest, Ident {
-                span: Span(span),
+                span: span,
                 sym: sym,
             }))
         }
@@ -272,7 +272,7 @@
     impl ToTokens for Ident {
         fn to_tokens(&self, tokens: &mut Tokens) {
             tokens.append(TokenTree {
-                span: self.span.0,
+                span: self.span,
                 kind: TokenNode::Term(self.sym),
             })
         }
diff --git a/src/lib.rs b/src/lib.rs
index 3f150b7..d850b2d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -111,9 +111,6 @@
 pub mod synom;
 pub mod delimited;
 
-mod span;
-pub use span::Span;
-
 mod gen {
     #[cfg(feature = "visit")]
     pub mod visit;
diff --git a/src/lifetime.rs b/src/lifetime.rs
index 31af27d..5d3c191 100644
--- a/src/lifetime.rs
+++ b/src/lifetime.rs
@@ -2,11 +2,9 @@
 use std::fmt::{self, Display};
 use std::hash::{Hash, Hasher};
 
-use proc_macro2::Term;
+use proc_macro2::{Span, Term};
 use unicode_xid::UnicodeXID;
 
-use Span;
-
 #[cfg_attr(feature = "extra-traits", derive(Debug))]
 #[cfg_attr(feature = "clone-impls", derive(Clone))]
 pub struct Lifetime {
@@ -108,7 +106,7 @@
 
             Ok((rest, Lifetime {
                 sym: sym,
-                span: Span(span),
+                span: span,
             }))
         }
     }
@@ -123,7 +121,7 @@
     impl ToTokens for Lifetime {
         fn to_tokens(&self, tokens: &mut Tokens) {
             tokens.append(TokenTree {
-                span: self.span.0,
+                span: self.span,
                 kind: TokenNode::Term(self.sym),
             })
         }
diff --git a/src/lit.rs b/src/lit.rs
index 850a8b0..f55e398 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -1,9 +1,9 @@
 use std::fmt;
 use std::hash::{Hash, Hasher};
 
-use proc_macro2::{self, Literal, TokenNode, Term};
+use proc_macro2::{self, Span, Literal, TokenNode, Term};
 
-use {Span, TokenTree};
+use TokenTree;
 
 #[derive(Clone)]
 pub struct Lit {
@@ -25,7 +25,7 @@
             LitKind::Other(l) => TokenNode::Literal(l),
         };
         TokenTree(proc_macro2::TokenTree {
-            span: self.span.0,
+            span: self.span,
             kind: kind,
         })
     }
@@ -110,7 +110,7 @@
             match input.literal() {
                 Some((rest, span, lit)) => {
                     Ok((rest, Lit {
-                        span: Span(span),
+                        span: span,
                         value: LitKind::Other(lit)
                     }))
                 }
@@ -125,7 +125,7 @@
                         };
 
                         Ok((rest, Lit {
-                            span: Span(span),
+                            span: span,
                             value: kind
                         }))
                     }
diff --git a/src/span.rs b/src/span.rs
deleted file mode 100644
index f78cff7..0000000
--- a/src/span.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use std::hash::{Hash, Hasher};
-use std::fmt::{self, Debug};
-
-use proc_macro2;
-
-#[derive(Clone, Copy, Default)]
-pub struct Span(pub proc_macro2::Span);
-
-impl Debug for Span {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl PartialEq for Span {
-    fn eq(&self, _other: &Span) -> bool {
-        true
-    }
-}
-
-impl Eq for Span {}
-
-impl Hash for Span {
-    fn hash<H: Hasher>(&self, _hasher: &mut H) {
-    }
-}
diff --git a/src/tokens.rs b/src/tokens.rs
index a40bd60..955b01d 100644
--- a/src/tokens.rs
+++ b/src/tokens.rs
@@ -5,7 +5,7 @@
 //! of these tokens and all implment the `ToTokens` and `Synom` traits when the
 //! corresponding feature is activated.
 
-use Span;
+use proc_macro2::Span;
 
 macro_rules! tokens {
     (
@@ -28,21 +28,33 @@
 macro_rules! op {
     (pub struct $name:ident($($contents:tt)*) => $s:expr) => {
         #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
-        #[cfg_attr(feature = "extra-traits", derive(Eq, PartialEq, Hash))]
         #[derive(Default)]
         pub struct $name(pub $($contents)*);
 
         #[cfg(feature = "extra-traits")]
         impl ::std::fmt::Debug for $name {
             fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                let mut t = f.debug_tuple(stringify!($name));
-                for span in &self.0 {
-                    t.field(span);
-                }
-                t.finish()
+                f.write_str(stringify!($name))
             }
         }
 
+        #[cfg(feature = "extra-traits")]
+        impl ::std::cmp::Eq for $name {}
+
+        #[cfg(feature = "extra-traits")]
+        impl ::std::cmp::PartialEq for $name {
+            fn eq(&self, _other: &$name) -> bool {
+                true
+            }
+        }
+
+        #[cfg(feature = "extra-traits")]
+        impl ::std::hash::Hash for $name {
+            fn hash<H>(&self, _state: &mut H)
+                where H: ::std::hash::Hasher
+            {}
+        }
+
         #[cfg(feature = "printing")]
         impl ::quote::ToTokens for $name {
             fn to_tokens(&self, tokens: &mut ::quote::Tokens) {
@@ -62,10 +74,33 @@
 macro_rules! sym {
     (pub struct $name:ident => $s:expr) => {
         #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
-        #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
         #[derive(Default)]
         pub struct $name(pub Span);
 
+        #[cfg(feature = "extra-traits")]
+        impl ::std::fmt::Debug for $name {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                f.write_str(stringify!($name))
+            }
+        }
+
+        #[cfg(feature = "extra-traits")]
+        impl ::std::cmp::Eq for $name {}
+
+        #[cfg(feature = "extra-traits")]
+        impl ::std::cmp::PartialEq for $name {
+            fn eq(&self, _other: &$name) -> bool {
+                true
+            }
+        }
+
+        #[cfg(feature = "extra-traits")]
+        impl ::std::hash::Hash for $name {
+            fn hash<H>(&self, _state: &mut H)
+                where H: ::std::hash::Hasher
+            {}
+        }
+
         #[cfg(feature = "printing")]
         impl ::quote::ToTokens for $name {
             fn to_tokens(&self, tokens: &mut ::quote::Tokens) {
@@ -85,10 +120,33 @@
 macro_rules! delim {
     (pub struct $name:ident => $s:expr) => {
         #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
-        #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
         #[derive(Default)]
         pub struct $name(pub Span);
 
+        #[cfg(feature = "extra-traits")]
+        impl ::std::fmt::Debug for $name {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                f.write_str(stringify!($name))
+            }
+        }
+
+        #[cfg(feature = "extra-traits")]
+        impl ::std::cmp::Eq for $name {}
+
+        #[cfg(feature = "extra-traits")]
+        impl ::std::cmp::PartialEq for $name {
+            fn eq(&self, _other: &$name) -> bool {
+                true
+            }
+        }
+
+        #[cfg(feature = "extra-traits")]
+        impl ::std::hash::Hash for $name {
+            fn hash<H>(&self, _state: &mut H)
+                where H: ::std::hash::Hasher
+            {}
+        }
+
         impl $name {
             #[cfg(feature = "printing")]
             pub fn surround<F>(&self,
@@ -399,10 +457,10 @@
 
 #[cfg(feature = "parsing")]
 mod parsing {
-    use proc_macro2::{Delimiter, Spacing};
+    use proc_macro2::{Span, Delimiter, Spacing};
 
     use cursor::Cursor;
-    use {PResult, Span, parse_error};
+    use {PResult, parse_error};
 
     pub trait FromSpans: Sized {
         fn from_spans(spans: &[Span]) -> Self;
@@ -445,7 +503,7 @@
                             _ => return parse_error(),
                         }
                     }
-                    *slot = Span(span);
+                    *slot = span;
                     tokens = rest;
                 }
                 _ => return parse_error()
@@ -461,7 +519,7 @@
     {
         if let Some((rest, span, s)) = tokens.word() {
             if s.as_str() == sym {
-                return Ok((rest, new(Span(span))));
+                return Ok((rest, new(span)));
             }
         }
         parse_error()
@@ -487,7 +545,7 @@
             match f(seqinfo.inside) {
                 Ok((remaining, ret)) => {
                     if remaining.eof() {
-                        return Ok((seqinfo.outside, (ret, new(Span(seqinfo.span)))));
+                        return Ok((seqinfo.outside, (ret, new(seqinfo.span))));
                     }
                 }
                 Err(err) => return Err(err),
@@ -499,11 +557,9 @@
 
 #[cfg(feature = "printing")]
 mod printing {
-    use proc_macro2::{TokenTree, TokenNode, Spacing, Term};
+    use proc_macro2::{Span, TokenTree, TokenNode, Spacing, Term};
     use quote::Tokens;
 
-    use Span;
-
     pub fn op(s: &str, spans: &[Span], tokens: &mut Tokens) {
         assert_eq!(s.len(), spans.len());
 
@@ -513,20 +569,20 @@
         let span = spans.next_back().unwrap();
         for (ch, span) in chars.zip(spans) {
             tokens.append(TokenTree {
-                span: span.0,
+                span: *span,
                 kind: TokenNode::Op(ch, Spacing::Joint),
             });
         }
 
         tokens.append(TokenTree {
-            span: span.0,
+            span: *span,
             kind: TokenNode::Op(ch, Spacing::Alone),
         });
     }
 
     pub fn sym(s: &str, span: &Span, tokens: &mut Tokens) {
         tokens.append(TokenTree {
-            span: span.0,
+            span: *span,
             kind: TokenNode::Term(Term::intern(s)),
         });
     }
@@ -534,6 +590,6 @@
     pub fn delim<F>(s: &str, span: &Span, tokens: &mut Tokens, f: F)
         where F: FnOnce(&mut Tokens)
     {
-        tokens.append_delimited(s, span.0, f)
+        tokens.append_delimited(s, *span, f)
     }
 }
diff --git a/syn_codegen/src/main.rs b/syn_codegen/src/main.rs
index 3b95262..3b8b16a 100644
--- a/syn_codegen/src/main.rs
+++ b/syn_codegen/src/main.rs
@@ -837,6 +837,7 @@
 
 use *;
 use delimited::Delimited;
+use proc_macro2::Span;
 
 trait FoldHelper {{
     type Item;
@@ -896,6 +897,7 @@
 #![cfg_attr(feature = \"cargo-clippy\", allow(match_same_arms))]
 
 use *;
+use proc_macro2::Span;
 
 {full_macro}
 
@@ -930,6 +932,7 @@
 #![cfg_attr(feature = \"cargo-clippy\", allow(match_same_arms))]
 
 use *;
+use proc_macro2::Span;
 
 {full_macro}
 
diff --git a/tests/test_generics.rs b/tests/test_generics.rs
index 96732a9..d24bc6e 100644
--- a/tests/test_generics.rs
+++ b/tests/test_generics.rs
@@ -9,7 +9,7 @@
 extern crate quote;
 
 extern crate proc_macro2;
-use proc_macro2::Term;
+use proc_macro2::{Span, Term};
 
 mod common;
 
diff --git a/tests/test_grouping.rs b/tests/test_grouping.rs
index f548947..a4b332e 100644
--- a/tests/test_grouping.rs
+++ b/tests/test_grouping.rs
@@ -26,7 +26,7 @@
 fn lit<T: Into<Literal>>(t: T) -> Expr {
     expr(Lit {
         value: LitKind::Other(t.into()),
-        span: syn::Span::default(),
+        span: Span::default(),
     })
 }