diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index 3d7495d..ae16090 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -1,12 +1,15 @@
 #![allow(dead_code)]
 
 extern crate walkdir;
+extern crate syntax;
 
 use std::env;
 use std::path::Path;
 use std::process::Command;
 use std::u32;
 
+use self::syntax::ast;
+
 use self::walkdir::DirEntry;
 
 macro_rules! errorf {
diff --git a/tests/common/respan.rs b/tests/common/respan.rs
index c191238..618cee0 100644
--- a/tests/common/respan.rs
+++ b/tests/common/respan.rs
@@ -5,7 +5,7 @@
 use self::syntax::ast::{Attribute, Expr, ExprKind, Field, FnDecl, FunctionRetTy, ImplItem,
                         ImplItemKind, ItemKind, Mac, MetaItem, MetaItemKind, MethodSig,
                         NestedMetaItem, NestedMetaItemKind, TraitItem, TraitItemKind, TyParam,
-                        Visibility};
+                        Visibility, Item, WhereClause};
 use self::syntax::codemap::{self, Spanned};
 use self::syntax::fold::{self, Folder};
 use self::syntax::parse::token::{Lit, Token};
@@ -46,6 +46,14 @@
         DUMMY_SP
     }
 
+    fn fold_item(&mut self, i: P<Item>) -> SmallVector<P<Item>> {
+        let i = i.map(|mut i| {
+            i.tokens = None;
+            i
+        });
+        fold::noop_fold_item(i, self)
+    }
+
     fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind {
         match i {
             ItemKind::Fn(decl, unsafety, constness, abi, generics, body) => {
@@ -122,38 +130,38 @@
         }
     }
 
-    fn fold_trait_item(&mut self, i: TraitItem) -> SmallVector<TraitItem> {
+    fn fold_trait_item(&mut self, mut i: TraitItem) -> SmallVector<TraitItem> {
+        i.tokens = None;
         let noop = fold::noop_fold_trait_item(i, self).expect_one("");
         SmallVector::one(TraitItem {
-                                node: match noop.node {
-                                    TraitItemKind::Method(sig, body) => {
+            node: match noop.node {
+                TraitItemKind::Method(sig, body) => {
                     TraitItemKind::Method(MethodSig {
-                                                constness: self.fold_spanned(sig.constness),
-                                                ..sig
-                                            },
-                                            body)
+                        constness: self.fold_spanned(sig.constness),
+                        ..sig
+                    }, body)
                 }
-                                    node => node,
-                                },
-                                ..noop
-                            })
+                node => node,
+            },
+            ..noop
+        })
     }
 
-    fn fold_impl_item(&mut self, i: ImplItem) -> SmallVector<ImplItem> {
+    fn fold_impl_item(&mut self, mut i: ImplItem) -> SmallVector<ImplItem> {
+        i.tokens = None;
         let noop = fold::noop_fold_impl_item(i, self).expect_one("");
         SmallVector::one(ImplItem {
-                                node: match noop.node {
-                                    ImplItemKind::Method(sig, body) => {
+            node: match noop.node {
+                ImplItemKind::Method(sig, body) => {
                     ImplItemKind::Method(MethodSig {
-                                                constness: self.fold_spanned(sig.constness),
-                                                ..sig
-                                            },
-                                            body)
+                        constness: self.fold_spanned(sig.constness),
+                        ..sig
+                    }, body)
                 }
-                                    node => node,
-                                },
-                                ..noop
-                            })
+                node => node,
+            },
+            ..noop
+        })
     }
 
     fn fold_attribute(&mut self, mut at: Attribute) -> Option<Attribute> {
@@ -192,48 +200,31 @@
         }
     }
 
+    // This folder is disabled by default.
     fn fold_mac(&mut self, mac: Mac) -> Mac {
         fold::noop_fold_mac(mac, self)
     }
 
-    fn fold_tt(&mut self, tt: TokenTree) -> TokenTree {
-        match tt {
-            TokenTree::Token(span, ref tok) => {
-                TokenTree::Token(self.new_span(span), self.fold_token(tok.clone()))
-            }
-            TokenTree::Delimited(span, ref delimed) => {
-                TokenTree::Delimited(self.new_span(span),
-                                        Delimited {
-                                            delim: delimed.delim,
-                                            tts: self.fold_tts(delimed.tts.clone().into()).into(),
-                                        })
-            }
-        }
-    }
-
     fn fold_token(&mut self, t: Token) -> Token {
-        match t {
+        fold::noop_fold_token(match t {
             // default fold_token does not fold literals
             Token::Literal(lit, repr) => Token::Literal(self.fold_lit(lit), repr),
-            Token::Ident(id) => Token::Ident(self.fold_ident(id)),
-            Token::Lifetime(id) => Token::Lifetime(self.fold_ident(id)),
-            Token::Interpolated(nt) => {
-                let nt = match Rc::try_unwrap(nt) {
-                    Ok(nt) => nt,
-                    Err(nt) => (*nt).clone(),
-                };
-                Token::Interpolated(Rc::new(self.fold_interpolated(nt)))
-            }
-            Token::SubstNt(ident) => Token::SubstNt(self.fold_ident(ident)),
             _ => t,
-        }
+        }, self)
     }
 
     fn fold_vis(&mut self, vis: Visibility) -> Visibility {
-        match vis {
-            Visibility::Crate(span) => Visibility::Crate(self.new_span(span)),
-            _ => fold::noop_fold_vis(vis, self),
-        }
+        fold::noop_fold_vis(match vis {
+            Visibility::Crate(span, sugar) =>
+                Visibility::Crate(self.new_span(span), sugar),
+            _ => vis,
+        }, self)
+    }
+
+    // noop_fold_where_clause doesn't modify the span.
+    fn fold_where_clause(&mut self, mut clause: WhereClause) -> WhereClause {
+        clause.span = self.new_span(clause.span);
+        fold::noop_fold_where_clause(clause, self)
     }
 }
 
diff --git a/tests/test_generics.rs b/tests/test_generics.rs
index eda415b..69e648f 100644
--- a/tests/test_generics.rs
+++ b/tests/test_generics.rs
@@ -1,5 +1,7 @@
 #![cfg(feature = "extra-traits")]
 
+#![feature(rustc_private)]
+
 extern crate syn;
 use syn::*;
 
diff --git a/tests/test_grouping.rs b/tests/test_grouping.rs
index 151af98..fa8b6eb 100644
--- a/tests/test_grouping.rs
+++ b/tests/test_grouping.rs
@@ -1,5 +1,7 @@
 #![cfg(all(feature = "extra-traits", feature = "full"))]
 
+#![feature(rustc_private)]
+
 extern crate syn;
 use syn::{Expr, ExprKind, ExprGroup, ExprBinary, Lit, LitKind, BinOp};
 
diff --git a/tests/test_precedence.rs b/tests/test_precedence.rs
index 0bddd39..9f43271 100644
--- a/tests/test_precedence.rs
+++ b/tests/test_precedence.rs
@@ -1,5 +1,7 @@
 #![cfg(all(feature = "full", feature = "fold"))]
 
+#![feature(rustc_private)]
+
 //! The tests in this module do the following:
 //!
 //! 1. Parse a given expression in both `syn` and `libsyntax`.