Get syn tests passing with libsyntax instead of syntex
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`.