diff --git a/src/expr.rs b/src/expr.rs
index 7c46224..17834d4 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -1,8 +1,12 @@
 use super::*;
 use delimited::Delimited;
-use proc_macro2::Span;
+use proc_macro2::{Span, TokenStream};
 #[cfg(feature = "extra-traits")]
 use std::hash::{Hash, Hasher};
+#[cfg(feature = "extra-traits")]
+use mac::TokenStreamHelper;
+#[cfg(feature = "full")]
+use std::mem;
 
 ast_enum_of_structs! {
     /// An expression.
@@ -370,6 +374,30 @@
             pub yield_token: Token![yield],
             pub expr: Option<Box<Expr>>,
         }),
+
+        pub Verbatim(ExprVerbatim #manual_extra_traits {
+            pub tts: TokenStream,
+        }),
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Eq for ExprVerbatim {}
+
+#[cfg(feature = "extra-traits")]
+impl PartialEq for ExprVerbatim {
+    fn eq(&self, other: &Self) -> bool {
+        TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Hash for ExprVerbatim {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        TokenStreamHelper(&self.tts).hash(state);
     }
 }
 
@@ -377,7 +405,7 @@
     // Not public API.
     #[doc(hidden)]
     #[cfg(feature = "full")]
-    pub fn attrs_mut(&mut self) -> &mut Vec<Attribute> {
+    pub fn replace_attrs(&mut self, new: Vec<Attribute>) -> Vec<Attribute> {
         match *self {
             Expr::Box(ExprBox { ref mut attrs, .. }) |
             Expr::InPlace(ExprInPlace { ref mut attrs, .. }) |
@@ -417,7 +445,13 @@
             Expr::Group(ExprGroup { ref mut attrs, .. }) |
             Expr::Try(ExprTry { ref mut attrs, .. }) |
             Expr::Catch(ExprCatch { ref mut attrs, .. }) |
-            Expr::Yield(ExprYield { ref mut attrs, .. }) => attrs,
+            Expr::Yield(ExprYield { ref mut attrs, .. }) => {
+                mem::replace(attrs, new)
+            }
+            Expr::Verbatim(_) => {
+                // TODO
+                Vec::new()
+            }
         }
     }
 }
@@ -648,6 +682,29 @@
         }),
         /// A macro pattern; pre-expansion
         pub Macro(Macro),
+        pub Verbatim(PatVerbatim #manual_extra_traits {
+            pub tts: TokenStream,
+        }),
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Eq for PatVerbatim {}
+
+#[cfg(feature = "extra-traits")]
+impl PartialEq for PatVerbatim {
+    fn eq(&self, other: &Self) -> bool {
+        TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Hash for PatVerbatim {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        TokenStreamHelper(&self.tts).hash(state);
     }
 }
 
@@ -1929,7 +1986,7 @@
                 attrs: many0!(Attribute::parse_outer) >>
                 mut e: syn!(Expr) >>
                 ({
-                    *e.attrs_mut() = attrs;
+                    e.replace_attrs(attrs);
                     Stmt::Expr(Box::new(e))
                 })
             )) >>
@@ -2015,7 +2072,7 @@
         not!(punct!(?)) >>
         semi: option!(punct!(;)) >>
         ({
-            *e.attrs_mut() = attrs;
+            e.replace_attrs(attrs);
             if let Some(semi) = semi {
                 Stmt::Semi(Box::new(e), semi)
             } else {
@@ -2030,7 +2087,7 @@
         mut e: syn!(Expr) >>
         semi: punct!(;) >>
         ({
-            *e.attrs_mut() = attrs;
+            e.replace_attrs(attrs);
             Stmt::Semi(Box::new(e), semi)
         })
     ));
@@ -2891,6 +2948,12 @@
         }
     }
 
+    impl ToTokens for ExprVerbatim {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            self.tts.to_tokens(tokens);
+        }
+    }
+
     #[cfg(feature = "full")]
     impl ToTokens for FieldValue {
         fn to_tokens(&self, tokens: &mut Tokens) {
@@ -3061,6 +3124,13 @@
     }
 
     #[cfg(feature = "full")]
+    impl ToTokens for PatVerbatim {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            self.tts.to_tokens(tokens);
+        }
+    }
+
+    #[cfg(feature = "full")]
     impl ToTokens for FieldPat {
         fn to_tokens(&self, tokens: &mut Tokens) {
             if let Some(ref colon_token) = self.colon_token {
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 19d5908..25c337b 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -149,6 +149,8 @@
 fn fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary { fold_expr_unary(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_expr_unsafe(&mut self, i: ExprUnsafe) -> ExprUnsafe { fold_expr_unsafe(self, i) }
+
+fn fold_expr_verbatim(&mut self, i: ExprVerbatim) -> ExprVerbatim { fold_expr_verbatim(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile { fold_expr_while(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -175,6 +177,8 @@
 fn fold_foreign_item_static(&mut self, i: ForeignItemStatic) -> ForeignItemStatic { fold_foreign_item_static(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_foreign_item_type(&mut self, i: ForeignItemType) -> ForeignItemType { fold_foreign_item_type(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn fold_foreign_item_verbatim(&mut self, i: ForeignItemVerbatim) -> ForeignItemVerbatim { fold_foreign_item_verbatim(self, i) }
 
 fn fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument { fold_generic_argument(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -195,6 +199,8 @@
 fn fold_impl_item_method(&mut self, i: ImplItemMethod) -> ImplItemMethod { fold_impl_item_method(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_impl_item_type(&mut self, i: ImplItemType) -> ImplItemType { fold_impl_item_type(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn fold_impl_item_verbatim(&mut self, i: ImplItemVerbatim) -> ImplItemVerbatim { fold_impl_item_verbatim(self, i) }
 
 fn fold_index(&mut self, i: Index) -> Index { fold_index(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -231,6 +237,8 @@
 fn fold_item_union(&mut self, i: ItemUnion) -> ItemUnion { fold_item_union(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_item_use(&mut self, i: ItemUse) -> ItemUse { fold_item_use(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn fold_item_verbatim(&mut self, i: ItemVerbatim) -> ItemVerbatim { fold_item_verbatim(self, i) }
 
 fn fold_lifetime(&mut self, i: Lifetime) -> Lifetime { fold_lifetime(self, i) }
 
@@ -280,6 +288,8 @@
 # [ cfg ( feature = "full" ) ]
 fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct { fold_pat_tuple_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
+fn fold_pat_verbatim(&mut self, i: PatVerbatim) -> PatVerbatim { fold_pat_verbatim(self, i) }
+# [ cfg ( feature = "full" ) ]
 fn fold_pat_wild(&mut self, i: PatWild) -> PatWild { fold_pat_wild(self, i) }
 
 fn fold_path(&mut self, i: Path) -> Path { fold_path(self, i) }
@@ -311,6 +321,8 @@
 fn fold_trait_item_method(&mut self, i: TraitItemMethod) -> TraitItemMethod { fold_trait_item_method(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_trait_item_type(&mut self, i: TraitItemType) -> TraitItemType { fold_trait_item_type(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn fold_trait_item_verbatim(&mut self, i: TraitItemVerbatim) -> TraitItemVerbatim { fold_trait_item_verbatim(self, i) }
 
 fn fold_type(&mut self, i: Type) -> Type { fold_type(self, i) }
 
@@ -346,6 +358,8 @@
 
 fn fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple { fold_type_tuple(self, i) }
 
+fn fold_type_verbatim(&mut self, i: TypeVerbatim) -> TypeVerbatim { fold_type_verbatim(self, i) }
+
 fn fold_un_op(&mut self, i: UnOp) -> UnOp { fold_un_op(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_use_glob(&mut self, i: UseGlob) -> UseGlob { fold_use_glob(self, i) }
@@ -906,6 +920,11 @@
                 full!(_visitor.fold_expr_yield(_binding_0)),
             )
         }
+        Verbatim(_binding_0, ) => {
+            Verbatim (
+                _visitor.fold_expr_verbatim(_binding_0),
+            )
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1241,6 +1260,12 @@
         block: _visitor.fold_block(_i . block),
     }
 }
+
+pub fn fold_expr_verbatim<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprVerbatim) -> ExprVerbatim {
+    ExprVerbatim {
+        tts: _i . tts,
+    }
+}
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_while<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprWhile) -> ExprWhile {
     ExprWhile {
@@ -1371,6 +1396,11 @@
                 _visitor.fold_foreign_item_type(_binding_0),
             )
         }
+        Verbatim(_binding_0, ) => {
+            Verbatim (
+                _visitor.fold_foreign_item_verbatim(_binding_0),
+            )
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1406,6 +1436,12 @@
         semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
     }
 }
+# [ cfg ( feature = "full" ) ]
+pub fn fold_foreign_item_verbatim<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItemVerbatim) -> ForeignItemVerbatim {
+    ForeignItemVerbatim {
+        tts: _i . tts,
+    }
+}
 
 pub fn fold_generic_argument<V: Folder + ?Sized>(_visitor: &mut V, _i: GenericArgument) -> GenericArgument {
     use ::GenericArgument::*;
@@ -1502,6 +1538,11 @@
                 _visitor.fold_impl_item_macro(_binding_0),
             )
         }
+        Verbatim(_binding_0, ) => {
+            Verbatim (
+                _visitor.fold_impl_item_verbatim(_binding_0),
+            )
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1551,6 +1592,12 @@
         semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
     }
 }
+# [ cfg ( feature = "full" ) ]
+pub fn fold_impl_item_verbatim<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItemVerbatim) -> ImplItemVerbatim {
+    ImplItemVerbatim {
+        tts: _i . tts,
+    }
+}
 
 pub fn fold_index<V: Folder + ?Sized>(_visitor: &mut V, _i: Index) -> Index {
     Index {
@@ -1642,6 +1689,11 @@
                 _visitor.fold_item_macro2(_binding_0),
             )
         }
+        Verbatim(_binding_0, ) => {
+            Verbatim (
+                _visitor.fold_item_verbatim(_binding_0),
+            )
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1850,6 +1902,12 @@
         semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
     }
 }
+# [ cfg ( feature = "full" ) ]
+pub fn fold_item_verbatim<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemVerbatim) -> ItemVerbatim {
+    ItemVerbatim {
+        tts: _i . tts,
+    }
+}
 
 pub fn fold_lifetime_def<V: Folder + ?Sized>(_visitor: &mut V, _i: LifetimeDef) -> LifetimeDef {
     LifetimeDef {
@@ -2047,6 +2105,11 @@
                 _visitor.fold_macro(_binding_0),
             )
         }
+        Verbatim(_binding_0, ) => {
+            Verbatim (
+                _visitor.fold_pat_verbatim(_binding_0),
+            )
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -2133,6 +2196,12 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
+pub fn fold_pat_verbatim<V: Folder + ?Sized>(_visitor: &mut V, _i: PatVerbatim) -> PatVerbatim {
+    PatVerbatim {
+        tts: _i . tts,
+    }
+}
+# [ cfg ( feature = "full" ) ]
 pub fn fold_pat_wild<V: Folder + ?Sized>(_visitor: &mut V, _i: PatWild) -> PatWild {
     PatWild {
         underscore_token: Token ! [ _ ](tokens_helper(_visitor, &(_i . underscore_token).0)),
@@ -2282,6 +2351,11 @@
                 _visitor.fold_trait_item_macro(_binding_0),
             )
         }
+        Verbatim(_binding_0, ) => {
+            Verbatim (
+                _visitor.fold_trait_item_verbatim(_binding_0),
+            )
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -2332,6 +2406,12 @@
         semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
     }
 }
+# [ cfg ( feature = "full" ) ]
+pub fn fold_trait_item_verbatim<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItemVerbatim) -> TraitItemVerbatim {
+    TraitItemVerbatim {
+        tts: _i . tts,
+    }
+}
 
 pub fn fold_type<V: Folder + ?Sized>(_visitor: &mut V, _i: Type) -> Type {
     use ::Type::*;
@@ -2406,6 +2486,11 @@
                 _visitor.fold_macro(_binding_0),
             )
         }
+        Verbatim(_binding_0, ) => {
+            Verbatim (
+                _visitor.fold_type_verbatim(_binding_0),
+            )
+        }
     }
 }
 
@@ -2546,6 +2631,12 @@
     }
 }
 
+pub fn fold_type_verbatim<V: Folder + ?Sized>(_visitor: &mut V, _i: TypeVerbatim) -> TypeVerbatim {
+    TypeVerbatim {
+        tts: _i . tts,
+    }
+}
+
 pub fn fold_un_op<V: Folder + ?Sized>(_visitor: &mut V, _i: UnOp) -> UnOp {
     use ::UnOp::*;
     match _i {
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index a191041..411651d 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -145,6 +145,8 @@
 fn visit_expr_unary(&mut self, i: &'ast ExprUnary) { visit_expr_unary(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_unsafe(&mut self, i: &'ast ExprUnsafe) { visit_expr_unsafe(self, i) }
+
+fn visit_expr_verbatim(&mut self, i: &'ast ExprVerbatim) { visit_expr_verbatim(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_while(&mut self, i: &'ast ExprWhile) { visit_expr_while(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -171,6 +173,8 @@
 fn visit_foreign_item_static(&mut self, i: &'ast ForeignItemStatic) { visit_foreign_item_static(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_foreign_item_type(&mut self, i: &'ast ForeignItemType) { visit_foreign_item_type(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_foreign_item_verbatim(&mut self, i: &'ast ForeignItemVerbatim) { visit_foreign_item_verbatim(self, i) }
 
 fn visit_generic_argument(&mut self, i: &'ast GenericArgument) { visit_generic_argument(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -191,6 +195,8 @@
 fn visit_impl_item_method(&mut self, i: &'ast ImplItemMethod) { visit_impl_item_method(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_impl_item_type(&mut self, i: &'ast ImplItemType) { visit_impl_item_type(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_impl_item_verbatim(&mut self, i: &'ast ImplItemVerbatim) { visit_impl_item_verbatim(self, i) }
 
 fn visit_index(&mut self, i: &'ast Index) { visit_index(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -227,6 +233,8 @@
 fn visit_item_union(&mut self, i: &'ast ItemUnion) { visit_item_union(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_item_use(&mut self, i: &'ast ItemUse) { visit_item_use(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_item_verbatim(&mut self, i: &'ast ItemVerbatim) { visit_item_verbatim(self, i) }
 
 fn visit_lifetime(&mut self, i: &'ast Lifetime) { visit_lifetime(self, i) }
 
@@ -276,6 +284,8 @@
 # [ cfg ( feature = "full" ) ]
 fn visit_pat_tuple_struct(&mut self, i: &'ast PatTupleStruct) { visit_pat_tuple_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
+fn visit_pat_verbatim(&mut self, i: &'ast PatVerbatim) { visit_pat_verbatim(self, i) }
+# [ cfg ( feature = "full" ) ]
 fn visit_pat_wild(&mut self, i: &'ast PatWild) { visit_pat_wild(self, i) }
 
 fn visit_path(&mut self, i: &'ast Path) { visit_path(self, i) }
@@ -307,6 +317,8 @@
 fn visit_trait_item_method(&mut self, i: &'ast TraitItemMethod) { visit_trait_item_method(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_trait_item_type(&mut self, i: &'ast TraitItemType) { visit_trait_item_type(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_trait_item_verbatim(&mut self, i: &'ast TraitItemVerbatim) { visit_trait_item_verbatim(self, i) }
 
 fn visit_type(&mut self, i: &'ast Type) { visit_type(self, i) }
 
@@ -342,6 +354,8 @@
 
 fn visit_type_tuple(&mut self, i: &'ast TypeTuple) { visit_type_tuple(self, i) }
 
+fn visit_type_verbatim(&mut self, i: &'ast TypeVerbatim) { visit_type_verbatim(self, i) }
+
 fn visit_un_op(&mut self, i: &'ast UnOp) { visit_un_op(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_use_glob(&mut self, i: &'ast UseGlob) { visit_use_glob(self, i) }
@@ -720,6 +734,9 @@
         Yield(ref _binding_0, ) => {
             full!(_visitor.visit_expr_yield(_binding_0));
         }
+        Verbatim(ref _binding_0, ) => {
+            _visitor.visit_expr_verbatim(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -983,6 +1000,10 @@
     tokens_helper(_visitor, &(& _i . unsafe_token).0);
     _visitor.visit_block(& _i . block);
 }
+
+pub fn visit_expr_verbatim<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprVerbatim) {
+    // Skipped field _i . tts;
+}
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_while<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprWhile) {
     for it in & _i . attrs { _visitor.visit_attribute(it) };
@@ -1081,6 +1102,9 @@
         Type(ref _binding_0, ) => {
             _visitor.visit_foreign_item_type(_binding_0);
         }
+        Verbatim(ref _binding_0, ) => {
+            _visitor.visit_foreign_item_verbatim(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1110,6 +1134,10 @@
     _visitor.visit_ident(& _i . ident);
     tokens_helper(_visitor, &(& _i . semi_token).0);
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_foreign_item_verbatim<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ForeignItemVerbatim) {
+    // Skipped field _i . tts;
+}
 
 pub fn visit_generic_argument<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast GenericArgument) {
     use ::GenericArgument::*;
@@ -1183,6 +1211,9 @@
         Macro(ref _binding_0, ) => {
             _visitor.visit_impl_item_macro(_binding_0);
         }
+        Verbatim(ref _binding_0, ) => {
+            _visitor.visit_impl_item_verbatim(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1224,6 +1255,10 @@
     _visitor.visit_type(& _i . ty);
     tokens_helper(_visitor, &(& _i . semi_token).0);
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_impl_item_verbatim<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ImplItemVerbatim) {
+    // Skipped field _i . tts;
+}
 
 pub fn visit_index<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Index) {
     // Skipped field _i . index;
@@ -1281,6 +1316,9 @@
         Macro2(ref _binding_0, ) => {
             _visitor.visit_item_macro2(_binding_0);
         }
+        Verbatim(ref _binding_0, ) => {
+            _visitor.visit_item_verbatim(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1457,6 +1495,10 @@
     _visitor.visit_use_tree(& _i . tree);
     tokens_helper(_visitor, &(& _i . semi_token).0);
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_item_verbatim<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemVerbatim) {
+    // Skipped field _i . tts;
+}
 
 pub fn visit_lifetime<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Lifetime) {
     // Skipped field _i . sym;
@@ -1603,6 +1645,9 @@
         Macro(ref _binding_0, ) => {
             _visitor.visit_macro(_binding_0);
         }
+        Verbatim(ref _binding_0, ) => {
+            _visitor.visit_pat_verbatim(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1669,6 +1714,10 @@
     _visitor.visit_pat_tuple(& _i . pat);
 }
 # [ cfg ( feature = "full" ) ]
+pub fn visit_pat_verbatim<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatVerbatim) {
+    // Skipped field _i . tts;
+}
+# [ cfg ( feature = "full" ) ]
 pub fn visit_pat_wild<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatWild) {
     tokens_helper(_visitor, &(& _i . underscore_token).0);
 }
@@ -1779,6 +1828,9 @@
         Macro(ref _binding_0, ) => {
             _visitor.visit_trait_item_macro(_binding_0);
         }
+        Verbatim(ref _binding_0, ) => {
+            _visitor.visit_trait_item_verbatim(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1821,6 +1873,10 @@
          };
     tokens_helper(_visitor, &(& _i . semi_token).0);
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_trait_item_verbatim<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TraitItemVerbatim) {
+    // Skipped field _i . tts;
+}
 
 pub fn visit_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Type) {
     use ::Type::*;
@@ -1867,6 +1923,9 @@
         Macro(ref _binding_0, ) => {
             _visitor.visit_macro(_binding_0);
         }
+        Verbatim(ref _binding_0, ) => {
+            _visitor.visit_type_verbatim(_binding_0);
+        }
     }
 }
 
@@ -1973,6 +2032,10 @@
     for el in & _i . elems { let it = el.item(); _visitor.visit_type(it) };
 }
 
+pub fn visit_type_verbatim<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeVerbatim) {
+    // Skipped field _i . tts;
+}
+
 pub fn visit_un_op<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UnOp) {
     use ::UnOp::*;
     match *_i {
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 12647fe..17afe9e 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -145,6 +145,8 @@
 fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) { visit_expr_unary_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) { visit_expr_unsafe_mut(self, i) }
+
+fn visit_expr_verbatim_mut(&mut self, i: &mut ExprVerbatim) { visit_expr_verbatim_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) { visit_expr_while_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -171,6 +173,8 @@
 fn visit_foreign_item_static_mut(&mut self, i: &mut ForeignItemStatic) { visit_foreign_item_static_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_foreign_item_type_mut(&mut self, i: &mut ForeignItemType) { visit_foreign_item_type_mut(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_foreign_item_verbatim_mut(&mut self, i: &mut ForeignItemVerbatim) { visit_foreign_item_verbatim_mut(self, i) }
 
 fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) { visit_generic_argument_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -191,6 +195,8 @@
 fn visit_impl_item_method_mut(&mut self, i: &mut ImplItemMethod) { visit_impl_item_method_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_impl_item_type_mut(&mut self, i: &mut ImplItemType) { visit_impl_item_type_mut(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_impl_item_verbatim_mut(&mut self, i: &mut ImplItemVerbatim) { visit_impl_item_verbatim_mut(self, i) }
 
 fn visit_index_mut(&mut self, i: &mut Index) { visit_index_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
@@ -227,6 +233,8 @@
 fn visit_item_union_mut(&mut self, i: &mut ItemUnion) { visit_item_union_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_item_use_mut(&mut self, i: &mut ItemUse) { visit_item_use_mut(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_item_verbatim_mut(&mut self, i: &mut ItemVerbatim) { visit_item_verbatim_mut(self, i) }
 
 fn visit_lifetime_mut(&mut self, i: &mut Lifetime) { visit_lifetime_mut(self, i) }
 
@@ -276,6 +284,8 @@
 # [ cfg ( feature = "full" ) ]
 fn visit_pat_tuple_struct_mut(&mut self, i: &mut PatTupleStruct) { visit_pat_tuple_struct_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
+fn visit_pat_verbatim_mut(&mut self, i: &mut PatVerbatim) { visit_pat_verbatim_mut(self, i) }
+# [ cfg ( feature = "full" ) ]
 fn visit_pat_wild_mut(&mut self, i: &mut PatWild) { visit_pat_wild_mut(self, i) }
 
 fn visit_path_mut(&mut self, i: &mut Path) { visit_path_mut(self, i) }
@@ -307,6 +317,8 @@
 fn visit_trait_item_method_mut(&mut self, i: &mut TraitItemMethod) { visit_trait_item_method_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_trait_item_type_mut(&mut self, i: &mut TraitItemType) { visit_trait_item_type_mut(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_trait_item_verbatim_mut(&mut self, i: &mut TraitItemVerbatim) { visit_trait_item_verbatim_mut(self, i) }
 
 fn visit_type_mut(&mut self, i: &mut Type) { visit_type_mut(self, i) }
 
@@ -342,6 +354,8 @@
 
 fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) { visit_type_tuple_mut(self, i) }
 
+fn visit_type_verbatim_mut(&mut self, i: &mut TypeVerbatim) { visit_type_verbatim_mut(self, i) }
+
 fn visit_un_op_mut(&mut self, i: &mut UnOp) { visit_un_op_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_use_glob_mut(&mut self, i: &mut UseGlob) { visit_use_glob_mut(self, i) }
@@ -720,6 +734,9 @@
         Yield(ref mut _binding_0, ) => {
             full!(_visitor.visit_expr_yield_mut(_binding_0));
         }
+        Verbatim(ref mut _binding_0, ) => {
+            _visitor.visit_expr_verbatim_mut(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -983,6 +1000,10 @@
     tokens_helper(_visitor, &mut (& mut _i . unsafe_token).0);
     _visitor.visit_block_mut(& mut _i . block);
 }
+
+pub fn visit_expr_verbatim_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprVerbatim) {
+    // Skipped field _i . tts;
+}
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_while_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhile) {
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
@@ -1081,6 +1102,9 @@
         Type(ref mut _binding_0, ) => {
             _visitor.visit_foreign_item_type_mut(_binding_0);
         }
+        Verbatim(ref mut _binding_0, ) => {
+            _visitor.visit_foreign_item_verbatim_mut(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1110,6 +1134,10 @@
     _visitor.visit_ident_mut(& mut _i . ident);
     tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_foreign_item_verbatim_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItemVerbatim) {
+    // Skipped field _i . tts;
+}
 
 pub fn visit_generic_argument_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut GenericArgument) {
     use ::GenericArgument::*;
@@ -1183,6 +1211,9 @@
         Macro(ref mut _binding_0, ) => {
             _visitor.visit_impl_item_macro_mut(_binding_0);
         }
+        Verbatim(ref mut _binding_0, ) => {
+            _visitor.visit_impl_item_verbatim_mut(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1224,6 +1255,10 @@
     _visitor.visit_type_mut(& mut _i . ty);
     tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_impl_item_verbatim_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemVerbatim) {
+    // Skipped field _i . tts;
+}
 
 pub fn visit_index_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Index) {
     // Skipped field _i . index;
@@ -1281,6 +1316,9 @@
         Macro2(ref mut _binding_0, ) => {
             _visitor.visit_item_macro2_mut(_binding_0);
         }
+        Verbatim(ref mut _binding_0, ) => {
+            _visitor.visit_item_verbatim_mut(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1457,6 +1495,10 @@
     _visitor.visit_use_tree_mut(& mut _i . tree);
     tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_item_verbatim_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemVerbatim) {
+    // Skipped field _i . tts;
+}
 
 pub fn visit_lifetime_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Lifetime) {
     // Skipped field _i . sym;
@@ -1603,6 +1645,9 @@
         Macro(ref mut _binding_0, ) => {
             _visitor.visit_macro_mut(_binding_0);
         }
+        Verbatim(ref mut _binding_0, ) => {
+            _visitor.visit_pat_verbatim_mut(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1669,6 +1714,10 @@
     _visitor.visit_pat_tuple_mut(& mut _i . pat);
 }
 # [ cfg ( feature = "full" ) ]
+pub fn visit_pat_verbatim_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatVerbatim) {
+    // Skipped field _i . tts;
+}
+# [ cfg ( feature = "full" ) ]
 pub fn visit_pat_wild_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatWild) {
     tokens_helper(_visitor, &mut (& mut _i . underscore_token).0);
 }
@@ -1779,6 +1828,9 @@
         Macro(ref mut _binding_0, ) => {
             _visitor.visit_trait_item_macro_mut(_binding_0);
         }
+        Verbatim(ref mut _binding_0, ) => {
+            _visitor.visit_trait_item_verbatim_mut(_binding_0);
+        }
     }
 }
 # [ cfg ( feature = "full" ) ]
@@ -1821,6 +1873,10 @@
          };
     tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
 }
+# [ cfg ( feature = "full" ) ]
+pub fn visit_trait_item_verbatim_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemVerbatim) {
+    // Skipped field _i . tts;
+}
 
 pub fn visit_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Type) {
     use ::Type::*;
@@ -1867,6 +1923,9 @@
         Macro(ref mut _binding_0, ) => {
             _visitor.visit_macro_mut(_binding_0);
         }
+        Verbatim(ref mut _binding_0, ) => {
+            _visitor.visit_type_verbatim_mut(_binding_0);
+        }
     }
 }
 
@@ -1973,6 +2032,10 @@
     for mut el in & mut _i . elems { let it = el.item_mut(); _visitor.visit_type_mut(it) };
 }
 
+pub fn visit_type_verbatim_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeVerbatim) {
+    // Skipped field _i . tts;
+}
+
 pub fn visit_un_op_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut UnOp) {
     use ::UnOp::*;
     match *_i {
diff --git a/src/item.rs b/src/item.rs
index 74ed612..0672dcc 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -1,9 +1,9 @@
 use super::*;
 use delimited::Delimited;
-use proc_macro2::TokenTree;
+use proc_macro2::{TokenTree, TokenStream};
 
 #[cfg(feature = "extra-traits")]
-use mac::TokenTreeHelper;
+use mac::{TokenTreeHelper, TokenStreamHelper};
 #[cfg(feature = "extra-traits")]
 use std::hash::{Hash, Hasher};
 
@@ -207,6 +207,9 @@
             pub args: TokenTree,
             pub body: TokenTree,
         }),
+        pub Verbatim(ItemVerbatim #manual_extra_traits {
+            pub tts: TokenStream,
+        }),
     }
 }
 
@@ -238,6 +241,26 @@
     }
 }
 
+#[cfg(feature = "extra-traits")]
+impl Eq for ItemVerbatim {}
+
+#[cfg(feature = "extra-traits")]
+impl PartialEq for ItemVerbatim {
+    fn eq(&self, other: &Self) -> bool {
+        TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Hash for ItemVerbatim {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        TokenStreamHelper(&self.tts).hash(state);
+    }
+}
+
 impl From<DeriveInput> for Item {
     fn from(input: DeriveInput) -> Item {
         match input.body {
@@ -313,6 +336,29 @@
             pub ident: Ident,
             pub semi_token: Token![;],
         }),
+        pub Verbatim(ForeignItemVerbatim #manual_extra_traits {
+            pub tts: TokenStream,
+        }),
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Eq for ForeignItemVerbatim {}
+
+#[cfg(feature = "extra-traits")]
+impl PartialEq for ForeignItemVerbatim {
+    fn eq(&self, other: &Self) -> bool {
+        TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Hash for ForeignItemVerbatim {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        TokenStreamHelper(&self.tts).hash(state);
     }
 }
 
@@ -352,6 +398,29 @@
             pub mac: Macro,
             pub semi_token: Option<Token![;]>,
         }),
+        pub Verbatim(TraitItemVerbatim #manual_extra_traits {
+            pub tts: TokenStream,
+        }),
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Eq for TraitItemVerbatim {}
+
+#[cfg(feature = "extra-traits")]
+impl PartialEq for TraitItemVerbatim {
+    fn eq(&self, other: &Self) -> bool {
+        TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Hash for TraitItemVerbatim {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        TokenStreamHelper(&self.tts).hash(state);
     }
 }
 
@@ -392,6 +461,29 @@
             pub mac: Macro,
             pub semi_token: Option<Token![;]>,
         }),
+        pub Verbatim(ImplItemVerbatim #manual_extra_traits {
+            pub tts: TokenStream,
+        }),
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Eq for ImplItemVerbatim {}
+
+#[cfg(feature = "extra-traits")]
+impl PartialEq for ImplItemVerbatim {
+    fn eq(&self, other: &Self) -> bool {
+        TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Hash for ImplItemVerbatim {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        TokenStreamHelper(&self.tts).hash(state);
     }
 }
 
@@ -1532,6 +1624,12 @@
         }
     }
 
+    impl ToTokens for ItemVerbatim {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            self.tts.to_tokens(tokens);
+        }
+    }
+
     impl ToTokens for UsePath {
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.ident.to_tokens(tokens);
@@ -1616,6 +1714,12 @@
         }
     }
 
+    impl ToTokens for TraitItemVerbatim {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            self.tts.to_tokens(tokens);
+        }
+    }
+
     impl ToTokens for ImplItemConst {
         fn to_tokens(&self, tokens: &mut Tokens) {
             tokens.append_all(self.attrs.outer());
@@ -1666,6 +1770,12 @@
         }
     }
 
+    impl ToTokens for ImplItemVerbatim {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            self.tts.to_tokens(tokens);
+        }
+    }
+
     impl ToTokens for ForeignItemFn {
         fn to_tokens(&self, tokens: &mut Tokens) {
             tokens.append_all(self.attrs.outer());
@@ -1698,6 +1808,12 @@
         }
     }
 
+    impl ToTokens for ForeignItemVerbatim {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            self.tts.to_tokens(tokens);
+        }
+    }
+
     impl ToTokens for MethodSig {
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.constness.to_tokens(tokens);
diff --git a/src/lib.rs b/src/lib.rs
index 3fe94d1..f465f30 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -38,12 +38,12 @@
                ExprField, ExprForLoop, ExprGroup, ExprIf, ExprIfLet, ExprInPlace, ExprIndex,
                ExprLit, ExprLoop, ExprMacro, ExprMatch, ExprMethodCall, ExprParen, ExprPath, ExprRange,
                ExprRepeat, ExprReturn, ExprStruct, ExprTry, ExprTuple, ExprType,
-               ExprUnary, ExprUnsafe, ExprWhile, ExprWhileLet, ExprYield, Index, Member};
+               ExprUnary, ExprUnsafe, ExprVerbatim, ExprWhile, ExprWhileLet, ExprYield, Index, Member};
 
 #[cfg(feature = "full")]
 pub use expr::{Arm, Block, FieldPat, FieldValue, GenericMethodArgument, Local,
                MethodTurbofish, Pat, PatBox, PatIdent, PatLit, PatPath, PatRange, PatRef, PatSlice,
-               PatStruct, PatTuple, PatTupleStruct, PatWild, RangeLimits, Stmt};
+               PatStruct, PatTuple, PatTupleStruct, PatVerbatim, PatWild, RangeLimits, Stmt};
 
 mod generics;
 pub use generics::{BoundLifetimes, ConstParam, GenericParam, Generics, LifetimeDef,
@@ -59,12 +59,12 @@
 mod item;
 #[cfg(feature = "full")]
 pub use item::{ArgCaptured, ArgSelf, ArgSelfRef, FnArg, FnDecl,
-               ForeignItem, ForeignItemFn, ForeignItemStatic, ForeignItemType, ImplItem,
-               ImplItemConst, ImplItemMacro, ImplItemMethod, ImplItemType, Item,
+               ForeignItem, ForeignItemFn, ForeignItemStatic, ForeignItemType, ForeignItemVerbatim, ImplItem,
+               ImplItemConst, ImplItemMacro, ImplItemMethod, ImplItemType, ImplItemVerbatim, Item,
                ItemConst, ItemDefaultImpl, ItemEnum, ItemExternCrate, ItemFn, ItemForeignMod,
                ItemImpl, ItemMacro, ItemMacro2, ItemMod, ItemStatic, ItemStruct, ItemTrait,
-               ItemType, ItemUnion, ItemUse, MethodSig, TraitItem, TraitItemConst, TraitItemMacro,
-               TraitItemMethod, TraitItemType, UseGlob, UseList, UsePath, UseTree};
+               ItemType, ItemUnion, ItemUse, ItemVerbatim, MethodSig, TraitItem, TraitItemConst, TraitItemMacro,
+               TraitItemMethod, TraitItemType, TraitItemVerbatim, UseGlob, UseList, UsePath, UseTree};
 
 #[cfg(feature = "full")]
 mod file;
@@ -91,7 +91,7 @@
              GenericArgument, ParenthesizedGenericArguments, Path,
              PathArguments, PathSegment, PolyTraitRef, QSelf, ReturnType, Type, TypeArray,
              TypeBareFn, TypeBinding, TypeGroup, TypeImplTrait, TypeInfer, TypeNever, TypeParen,
-             TypePath, TypePtr, TypeReference, TypeSlice, TypeTraitObject, TypeTuple};
+             TypePath, TypePtr, TypeReference, TypeSlice, TypeTraitObject, TypeTuple, TypeVerbatim};
 #[cfg(feature = "printing")]
 pub use ty::PathTokens;
 
diff --git a/src/ty.rs b/src/ty.rs
index 7cc7843..e26c52e 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -1,5 +1,10 @@
 use delimited::Delimited;
 use super::*;
+use proc_macro2::TokenStream;
+#[cfg(feature = "extra-traits")]
+use std::hash::{Hash, Hasher};
+#[cfg(feature = "extra-traits")]
+use mac::TokenStreamHelper;
 
 ast_enum_of_structs! {
     /// The different kinds of types recognized by the compiler
@@ -87,6 +92,29 @@
         }),
         /// A macro in the type position.
         pub Macro(Macro),
+        pub Verbatim(TypeVerbatim #manual_extra_traits {
+            pub tts: TokenStream,
+        }),
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Eq for TypeVerbatim {}
+
+#[cfg(feature = "extra-traits")]
+impl PartialEq for TypeVerbatim {
+    fn eq(&self, other: &Self) -> bool {
+        TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
+    }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Hash for TypeVerbatim {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        TokenStreamHelper(&self.tts).hash(state);
     }
 }
 
@@ -941,6 +969,12 @@
         }
     }
 
+    impl ToTokens for TypeVerbatim {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            self.tts.to_tokens(tokens);
+        }
+    }
+
     impl ToTokens for Path {
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.leading_colon.to_tokens(tokens);