diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index cfd681e51f4e..99f375c32868 100644
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -1663,7 +1663,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
             this.ty_infer(None, None, None, ast_ty.span)
         }
         ast::TyMac(_) => {
-            tcx.sess.span_bug(m.span, "unexpanded type macro found conversion")
+            tcx.sess.span_bug(ast_ty.span, "unexpanded type macro found conversion")
         }
     };
 
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 28c7ead20bca..1b5dcf648334 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -416,19 +416,22 @@ impl DummyResult {
 
     pub fn raw_ty(sp: Span) -> P<ast::Ty> {
         P(ast::Ty {
-            id: ast:DUMMY_NODE_ID,
+            id: ast::DUMMY_NODE_ID,
             node: ast::TyInfer,
             span: sp
         })
+    }
 }
 
 impl MacResult for DummyResult {
     fn make_expr(self: Box<DummyResult>) -> Option<P<ast::Expr>> {
         Some(DummyResult::raw_expr(self.span))
     }
+
     fn make_pat(self: Box<DummyResult>) -> Option<P<ast::Pat>> {
         Some(P(DummyResult::raw_pat(self.span)))
     }
+
     fn make_items(self: Box<DummyResult>) -> Option<SmallVector<P<ast::Item>>> {
         // this code needs a comment... why not always just return the Some() ?
         if self.expr_only {
@@ -437,6 +440,7 @@ impl MacResult for DummyResult {
             Some(SmallVector::zero())
         }
     }
+
     fn make_impl_items(self: Box<DummyResult>) -> Option<SmallVector<P<ast::ImplItem>>> {
         if self.expr_only {
             None
@@ -444,6 +448,7 @@ impl MacResult for DummyResult {
             Some(SmallVector::zero())
         }
     }
+
     fn make_stmts(self: Box<DummyResult>) -> Option<SmallVector<P<ast::Stmt>>> {
         Some(SmallVector::one(P(
             codemap::respan(self.span,
diff --git a/src/test/run-pass/type-macros.rs b/src/test/run-pass/type-macros.rs
new file mode 100644
index 000000000000..3ca3be8efed4
--- /dev/null
+++ b/src/test/run-pass/type-macros.rs
@@ -0,0 +1,82 @@
+// 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], ()])
+}
+