syntax: Add unquoting ast::{Generics,WhereClause}

Author: erickt

src/libsyntax/ext/quote.rs

@@ -94,6 +94,18 @@ pub mod rt {
         }
     }
 
+    impl ToTokens for ast::Generics {
+        fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
+            vec![ast::TtToken(DUMMY_SP, token::Interpolated(token::NtGenerics(self.clone())))]
+        }
+    }
+
+    impl ToTokens for ast::WhereClause {
+        fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
+            vec![ast::TtToken(DUMMY_SP, token::Interpolated(token::NtWhereClause(self.clone())))]
+        }
+    }
+
     impl ToTokens for P<ast::Item> {
         fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
             vec![ast::TtToken(self.span, token::Interpolated(token::NtItem(self.clone())))]

src/libsyntax/fold.rs

@@ -689,6 +689,9 @@ pub fn noop_fold_interpolated<T: Folder>(nt: token::Nonterminal, fld: &mut T)
         token::NtTraitItem(arm) =>
             token::NtTraitItem(fld.fold_trait_item(arm)
                                .expect_one("expected fold to produce exactly one item")),
+        token::NtGenerics(generics) => token::NtGenerics(fld.fold_generics(generics)),
+        token::NtWhereClause(where_clause) =>
+            token::NtWhereClause(fld.fold_where_clause(where_clause)),
     }
 }
 

src/libsyntax/parse/parser.rs

@@ -3829,6 +3829,8 @@ impl<'a> Parser<'a> {
     ///                  | ( < lifetimes , typaramseq ( , )? > )
     /// where   typaramseq = ( typaram ) | ( typaram , typaramseq )
     pub fn parse_generics(&mut self) -> PResult<ast::Generics> {
+        maybe_whole!(self, NtGenerics);
+
         if try!(self.eat(&token::Lt) ){
             let lifetime_defs = try!(self.parse_lifetime_defs());
             let mut seen_default = false;
@@ -3949,6 +3951,8 @@ impl<'a> Parser<'a> {
     /// where T : Trait<U, V> + 'b, 'a : 'b
     /// ```
     pub fn parse_where_clause(&mut self) -> PResult<ast::WhereClause> {
+        maybe_whole!(self, NtWhereClause);
+
         let mut where_clause = WhereClause {
             id: ast::DUMMY_NODE_ID,
             predicates: Vec::new(),

src/libsyntax/parse/token.rs

@@ -385,6 +385,8 @@ pub enum Nonterminal {
     NtArm(ast::Arm),
     NtImplItem(P<ast::ImplItem>),
     NtTraitItem(P<ast::TraitItem>),
+    NtGenerics(ast::Generics),
+    NtWhereClause(ast::WhereClause),
 }
 
 impl fmt::Debug for Nonterminal {
@@ -403,6 +405,8 @@ impl fmt::Debug for Nonterminal {
             NtArm(..) => f.pad("NtArm(..)"),
             NtImplItem(..) => f.pad("NtImplItem(..)"),
             NtTraitItem(..) => f.pad("NtTraitItem(..)"),
+            NtGenerics(..) => f.pad("NtGenerics(..)"),
+            NtWhereClause(..) => f.pad("NtWhereClause(..)"),
         }
     }
 }

src/libsyntax/print/pprust.rs

@@ -287,19 +287,21 @@ pub fn token_to_string(tok: &Token) -> String {
         token::SpecialVarNt(var)    => format!("${}", var.as_str()),
 
         token::Interpolated(ref nt) => match *nt {
-            token::NtExpr(ref e)      => expr_to_string(&**e),
-            token::NtMeta(ref e)      => meta_item_to_string(&**e),
-            token::NtTy(ref e)        => ty_to_string(&**e),
-            token::NtPath(ref e)      => path_to_string(&**e),
-            token::NtItem(ref e)      => item_to_string(&**e),
-            token::NtBlock(ref e)     => block_to_string(&**e),
-            token::NtStmt(ref e)      => stmt_to_string(&**e),
-            token::NtPat(ref e)       => pat_to_string(&**e),
-            token::NtIdent(ref e)     => ident_to_string(&**e),
-            token::NtTT(ref e)        => tt_to_string(&**e),
-            token::NtArm(ref e)       => arm_to_string(&**e),
-            token::NtImplItem(ref e)  => impl_item_to_string(&**e),
-            token::NtTraitItem(ref e) => trait_item_to_string(&**e),
+            token::NtExpr(ref e)        => expr_to_string(&**e),
+            token::NtMeta(ref e)        => meta_item_to_string(&**e),
+            token::NtTy(ref e)          => ty_to_string(&**e),
+            token::NtPath(ref e)        => path_to_string(&**e),
+            token::NtItem(ref e)        => item_to_string(&**e),
+            token::NtBlock(ref e)       => block_to_string(&**e),
+            token::NtStmt(ref e)        => stmt_to_string(&**e),
+            token::NtPat(ref e)         => pat_to_string(&**e),
+            token::NtIdent(ref e, _)    => ident_to_string(&**e),
+            token::NtTT(ref e)          => tt_to_string(&**e),
+            token::NtArm(ref e)         => arm_to_string(&*e),
+            token::NtImplItem(ref e)    => impl_item_to_string(&**e),
+            token::NtTraitItem(ref e)   => trait_item_to_string(&**e),
+            token::NtGenerics(ref e)    => generics_to_string(&*e),
+            token::NtWhereClause(ref e) => where_clause_to_string(&*e),
         }
     }
 }