Address nits

src/libsyntax/ext/expand.rs

@@ -1567,7 +1567,6 @@ pub fn expand_type(t: P<ast::Ty>, fld: &mut MacroExpander) -> P<ast::Ty> {
                 };
 
                 // Keep going, outside-in.
-                //
                 let fully_expanded = fld.fold_ty(expanded_ty);
                 fld.cx.bt_pop();
 

src/test/run-pass/type-macros.rs

@@ -1,84 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::ops::*;
-
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-struct Nil; // empty HList
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-struct Cons<H, T: HList>(H, T); // cons cell of HList
-
-// trait to classify valid HLists
-trait HList {}
-impl HList for Nil {}
-impl<H, T: HList> HList for Cons<H, T> {}
-
-// term-level macro for HLists
-macro_rules! hlist {
-        {} => { Nil };
-            { $head:expr } => { Cons($head, Nil) };
-                { $head:expr, $($tail:expr),* } => { Cons($head, hlist!($($tail),*)) };
-}
-
-// type-level macro for HLists
-macro_rules! HList {
-        {} => { Nil };
-            { $head:ty } => { Cons<$head, Nil> };
-                { $head:ty, $($tail:ty),* } => { Cons<$head, HList!($($tail),*)> };
-}
-
-// nil case for HList append
-impl<Ys: HList> Add<Ys> for Nil {
-        type Output = Ys;
-
-            fn add(self, rhs: Ys) -> Ys {
-                        rhs
-                                }
-}
-
-// cons case for HList append
-impl<Rec: HList + Sized, X, Xs: HList, Ys: HList> Add<Ys> for Cons<X, Xs> where
-    Xs: Add<Ys, Output = Rec>,
-{
-        type Output = Cons<X, Rec>;
-
-            fn add(self, rhs: Ys) -> Cons<X, Rec> {
-                        Cons(self.0, self.1 + rhs)
-                                }
-}
-
-// type macro Expr allows us to expand the + operator appropriately
-macro_rules! Expr {
-        { ( $($LHS:tt)+ ) } => { Expr!($($LHS)+) };
-        { HList ! [ $($LHS:tt)* ] + $($RHS:tt)+ } => {
-            <Expr!(HList![$($LHS)*]) as Add<Expr!($($RHS)+)>>::Output
-        };
-        { $LHS:tt + $($RHS:tt)+ } => { <Expr!($LHS) as Add<Expr!($($RHS)+)>>::Output };
-        { $LHS:ty } => { $LHS };
-}
-
-// test demonstrating term level `xs + ys` and type level `Expr!(Xs + Ys)`
-fn main() {
-    fn aux<Xs: HList, Ys: HList>(xs: Xs, ys: Ys) -> Expr!(Xs + Ys)
-        where Xs: Add<Ys> {
-            xs + ys
-        }
-
-    let xs: HList![&str, bool, Vec<u64>] = hlist!["foo", false, vec![]];
-    let ys: HList![u64, [u8; 3], ()] = hlist![0, [0, 1, 2], ()];
-
-    // demonstrate recursive expansion of Expr!
-    let zs: Expr!((HList![&str] + HList![bool] + HList![Vec<u64>]) +
-                  (HList![u64] + HList![[u8; 3], ()]) +
-                  HList![])
-        = aux(xs, ys);
-    assert_eq!(zs, hlist!["foo", false, vec![], 0, [0, 1, 2], ()])
-}
-