Initial stab at porting to new proc macro interface

maud/Cargo.toml

@@ -13,6 +13,7 @@ description = "Compile-time HTML templates."
 categories = ["template-engine"]
 
 [dependencies]
+maud_macros = { version = "0.16.3", path = "../maud_macros" }
 iron = { version = "0.5.1", optional = true }
 rocket = { version = "0.3", optional = true }
 

maud/src/lib.rs

@@ -1,3 +1,4 @@
+#![feature(proc_macro)]
 #![feature(specialization)]
 
 //! A macro for writing HTML templates.
@@ -12,8 +13,12 @@
 #[cfg(feature = "iron")] extern crate iron;
 #[cfg(feature = "rocket")] extern crate rocket;
 
+extern crate maud_macros;
+
 use std::fmt::{self, Write};
 
+pub use maud_macros::{html, html_debug};
+
 /// Represents a type that can be rendered as HTML.
 ///
 /// If your type implements [`Display`][1], then it will implement this

maud/tests/basic_syntax.rs

@@ -1,9 +1,8 @@
-#![feature(plugin)]
+#![feature(proc_macro)]
-#![plugin(maud_macros)]
 
 extern crate maud;
 
-use maud::Markup;
+use maud::{Markup, html};
 
 #[test]
 fn literals() {

maud/tests/control_structures.rs

@@ -1,8 +1,9 @@
-#![feature(conservative_impl_trait, plugin)]
+#![feature(conservative_impl_trait, proc_macro)]
-#![plugin(maud_macros)]
 
 extern crate maud;
 
+use maud::html;
+
 #[test]
 fn if_expr() {
     for (number, &name) in (1..4).zip(["one", "two", "three"].iter()) {

maud/tests/misc.rs

@@ -1,8 +1,9 @@
-#![feature(plugin)]
+#![feature(proc_macro)]
-#![plugin(maud_macros)]
 
 extern crate maud;
 
+use maud::html;
+
 #[test]
 fn issue_13() {
     let owned = String::from("yay");

maud/tests/splices.rs

@@ -1,8 +1,9 @@
-#![feature(plugin)]
+#![feature(proc_macro)]
-#![plugin(maud_macros)]
 
 extern crate maud;
 
+use maud::html;
+
 #[test]
 fn literals() {
     let s = html!(("<pinkie>")).into_string();

maud_macros/Cargo.toml

@@ -13,11 +13,11 @@ description = "Compile-time HTML templates."
 
 [dependencies]
 if_chain = "0.1"
-maud = { path = "../maud", version = "0.16.0" }
+literalext = { git = "https://github.com/mystor/literalext.git", default-features = false, features = ["proc-macro"] }
 
 [lib]
 name = "maud_macros"
-plugin = true
+proc-macro = true
 
 [badges]
 travis-ci = { repository = "lfairy/maud" }

maud_macros/src/lib.rs

@@ -1,53 +1,46 @@
-#![crate_type = "dylib"]
+#![feature(proc_macro)]
-#![feature(plugin_registrar, quote)]
-#![feature(slice_patterns)]
-#![feature(rustc_private)]
 #![recursion_limit = "1000"]  // if_chain
 
 #![doc(html_root_url = "https://docs.rs/maud_macros/0.16.3")]
 
 #[macro_use]
 extern crate if_chain;
-#[macro_use]
+extern crate literalext;
-extern crate rustc;
+extern crate proc_macro;
-extern crate rustc_plugin;
-extern crate syntax;
-extern crate maud;
 
-use rustc_plugin::Registry;
+// TODO move lints into their own `maud_lints` crate
-use syntax::codemap::Span;
+// mod lints;
-use syntax::ext::base::{DummyResult, ExtCtxt, MacEager, MacResult};
-use syntax::print::pprust;
-use syntax::tokenstream::TokenTree;
-
-mod lints;
 mod parse;
 mod render;
 
-type ParseResult<T> = Result<T, ()>;
+use proc_macro::TokenStream;
 
-fn expand_html<'cx>(cx: &'cx mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<MacResult + 'cx> {
+type ParseResult<T> = Result<T, String>;
-    match parse::parse(cx, sp, args) {
+
-        Ok(expr) => MacEager::expr(quote_expr!(cx, $expr)),
+#[proc_macro]
-        Err(..) => DummyResult::expr(sp),
+pub fn html(args: TokenStream) -> TokenStream {
+    match parse::parse(args) {
+        Ok(expr) => expr,
+        Err(e) => panic!(e),
     }
 }
 
-fn expand_html_debug<'cx>(cx: &'cx mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<MacResult + 'cx> {
+#[proc_macro]
-    match parse::parse(cx, sp, args) {
+pub fn html_debug(args: TokenStream) -> TokenStream {
+    match parse::parse(args) {
         Ok(expr) => {
-            let expr = quote_expr!(cx, $expr);
+            println!("expansion:\n{}", expr);
-            cx.span_warn(sp, &format!("expansion:\n{}",
+            expr
-                                      pprust::expr_to_string(&expr)));
-            MacEager::expr(expr)
         },
-        Err(..) => DummyResult::expr(sp),
+        Err(e) => panic!(e),
     }
 }
 
+/*
 #[plugin_registrar]
 pub fn plugin_registrar(reg: &mut Registry) {
     reg.register_macro("html", expand_html);
     reg.register_macro("html_debug", expand_html_debug);
     lints::register_lints(reg);
 }
+*/

maud_macros/src/parse.rs

@@ -1,484 +1,246 @@
+use proc_macro::{Delimiter, Literal, TokenNode, TokenStream, TokenTree, TokenTreeIter};
 use std::mem;
-use syntax::ast::LitKind;
+
-use syntax::codemap::Span;
+use literalext::LiteralExt;
-use syntax::ext::base::ExtCtxt;
-use syntax::parse;
-use syntax::parse::token::{BinOpToken, DelimToken, Token};
-use syntax::print::pprust;
-use syntax::symbol::keywords;
-use syntax::tokenstream::{Delimited, TokenStream, TokenTree};
 
 use super::render::Renderer;
 use super::ParseResult;
 
-macro_rules! at {
+pub fn parse(input: TokenStream) -> ParseResult<TokenStream> {
-    () => (TokenTree::Token(_, Token::At))
+    let mut render = Renderer::new();
-}
+    let _ = Parser {
-macro_rules! dot {
-    () => (TokenTree::Token(_, Token::Dot))
-}
-macro_rules! eq {
-    () => (TokenTree::Token(_, Token::Eq))
-}
-macro_rules! pound {
-    () => (TokenTree::Token(_, Token::Pound))
-}
-macro_rules! question {
-    () => (TokenTree::Token(_, Token::Question))
-}
-macro_rules! semi {
-    () => (TokenTree::Token(_, Token::Semi))
-}
-macro_rules! colon {
-    () => (TokenTree::Token(_, Token::Colon))
-}
-macro_rules! comma {
-    () => (TokenTree::Token(_, Token::Comma))
-}
-macro_rules! fat_arrow {
-    () => (TokenTree::Token(_, Token::FatArrow))
-}
-macro_rules! minus {
-    () => (TokenTree::Token(_, Token::BinOp(BinOpToken::Minus)))
-}
-macro_rules! slash {
-    () => (TokenTree::Token(_, Token::BinOp(BinOpToken::Slash)))
-}
-macro_rules! literal {
-    () => (TokenTree::Token(_, Token::Literal(..)))
-}
-macro_rules! ident {
-    ($sp:pat, $x:pat) => (TokenTree::Token($sp, Token::Ident($x)))
-}
-macro_rules! keyword {
-    ($sp:pat, $x:ident) => (TokenTree::Token($sp, ref $x @ Token::Ident(..)))
-}
-
-pub fn parse(cx: &ExtCtxt, sp: Span, input: &[TokenTree]) -> ParseResult<Vec<TokenTree>> {
-    let mut render = Renderer::new(cx);
-    Parser {
-        cx,
         in_attr: false,
-        input: input,
+        input: Lookahead::new(input.clone()),
-        span: sp,
+    }.markups(&mut render);
+    /*
+    Parser {
+        in_attr: false,
+        input: Lookahead::new(input.clone()),
     }.markups(&mut render)?;
+    */
     // Heuristic: the size of the resulting markup tends to correlate with the
     // code size of the template itself
-    let size_hint = pprust::tts_to_string(input).len();
+    let size_hint = input.to_string().len();
-    Ok(render.into_expr(size_hint).into_trees().collect())
+    Ok(render.into_expr(size_hint))
 }
 
-struct Parser<'cx, 'a: 'cx, 'i> {
+struct Parser {
-    cx: &'cx ExtCtxt<'a>,
     in_attr: bool,
-    input: &'i [TokenTree],
+    input: Lookahead<TokenTree>,
-    span: Span,
 }
 
-impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
+impl Parser {
-    /// Consumes `n` items from the input.
+    fn next(&mut self) -> Option<TokenNode> {
-    fn shift(&mut self, n: usize) {
+        self.input.next().map(|tt| tt.kind)
-        self.input = &self.input[n..];
+    }
+
+    fn peek(&mut self) -> Option<TokenNode> {
+        self.input.peek().map(|tt| tt.kind)
+    }
+
+    fn advance(&mut self) {
+        self.next();
     }
 
     /// Attaches an error message to the span and returns `Err`.
-    fn error<T>(&self, span: Span, message: &str) -> ParseResult<T> {
+    fn error<T, E: Into<String>>(&self, message: E) -> ParseResult<T> {
-        self.cx.span_err(span, message);
+        Err(message.into())
-        Err(())
     }
 
     /// Parses and renders multiple blocks of markup.
     fn markups(&mut self, render: &mut Renderer) -> ParseResult<()> {
         loop {
-            match *self.input {
+            match self.peek() {
-                [] => return Ok(()),
+                None => return Ok(()),
-                [semi!(), ..] => self.shift(1),
+                Some(TokenNode::Op(';', _)) => self.advance(),
-                [_, ..] => self.markup(render)?,
+                _ => self.markup(render)?,
             }
         }
     }
 
     /// Parses and renders a single block of markup.
     fn markup(&mut self, render: &mut Renderer) -> ParseResult<()> {
-        match *self.input {
+        let token = match self.peek() {
+            Some(token) => token,
+            None => return self.error("unexpected end of input"),
+        };
+        match token {
             // Literal
-            [ref tt @ literal!(), ..] => {
+            TokenNode::Literal(lit) => {
-                self.shift(1);
+                self.advance();
-                self.literal(tt, render)?;
+                self.literal(lit, render)?;
             },
-            // If
+            // Special form
-            [at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::If) => {
+            TokenNode::Op('@', _) => {
-                self.shift(2);
+                self.advance();
-                self.if_expr(sp, render)?;
+                match self.next() {
-            },
+                    Some(TokenNode::Term(term)) => match term.as_str() {
-            // While
+                        "if" => self.if_expr(render)?,
-            [at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::While) => {
+                        "while" => self.while_expr(render)?,
-                self.shift(2);
+                        "for" => self.for_expr(render)?,
-                self.while_expr(sp, render)?;
+                        "match" => self.match_expr(render)?,
-            },
+                        "let" => self.let_expr(render)?,
-            // For
+                        other => return self.error(format!("unknown keyword `@{}`", other)),
-            [at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::For) => {
+                    },
-                self.shift(2);
+                    _ => return self.error("expected keyword after `@`"),
-                self.for_expr(sp, render)?;
+                }
-            },
-            // Match
-            [at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::Match) => {
-                self.shift(2);
-                self.match_expr(sp, render)?;
-            },
-            // Let
-            [at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::Let) => {
-                self.shift(2);
-                self.let_expr(sp, render)?;
             }
             // Element
-            [ident!(sp, _), ..] => {
+            TokenNode::Term(_) => {
-                let name = self.namespaced_name().unwrap();
+                let name = self.namespaced_name()?;
-                self.element(sp, &name, render)?;
+                self.element(&name, render)?;
             },
             // Splice
-            [TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Paren => {
+            TokenNode::Group(Delimiter::Parenthesis, expr) => {
-                self.shift(1);
+                self.advance();
-                render.splice(d.stream());
+                render.splice(expr);
             }
             // Block
-            [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
+            TokenNode::Group(Delimiter::Brace, block) => {
-                self.shift(1);
+                self.advance();
                 Parser {
-                    cx: self.cx,
                     in_attr: self.in_attr,
-                    input: &d.stream().into_trees().collect::<Vec<_>>(),
+                    input: Lookahead::new(block),
-                    span: sp,
                 }.markups(render)?;
             },
             // ???
-            _ => {
+            _ => return self.error("invalid syntax"),
-                if let [ref tt, ..] = *self.input {
-                    return self.error(tt.span(), "invalid syntax");
-                } else {
-                    return self.error(self.span, "unexpected end of block");
-                }
-            },
         }
         Ok(())
     }
 
     /// Parses and renders a literal string.
-    fn literal(&mut self, tt: &TokenTree, render: &mut Renderer) -> ParseResult<()> {
+    fn literal(&mut self, lit: Literal, render: &mut Renderer) -> ParseResult<()> {
-        let mut rust_parser = parse::stream_to_parser(self.cx.parse_sess, tt.clone().into());
+        if let Some(s) = lit.parse_string() {
-        let lit = rust_parser.parse_lit().map_err(|mut e| e.emit())?;
+            render.string(&s);
-        if let LitKind::Str(s, _) = lit.node {
-            render.string(&s.as_str());
             Ok(())
         } else {
-            return self.error(lit.span, "literal strings must be surrounded by quotes (\"like this\")")
+            self.error("expected string")
         }
     }
 
     /// Parses and renders an `@if` expression.
     ///
     /// The leading `@if` should already be consumed.
-    fn if_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
+    fn if_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
-        // Parse the initial if
+        self.error("unimplemented")
-        let mut if_cond = vec![];
-        let if_body;
-        loop { match *self.input {
-            [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
-                self.shift(1);
-                if_body = self.block(sp, d.stream(), render)?;
-                break;
-            },
-            [ref tt, ..] => {
-                self.shift(1);
-                if_cond.push(tt.clone());
-            },
-            [] => return self.error(sp, "expected body for this @if"),
-        }}
-        // Parse the (optional) @else
-        let else_body = match *self.input {
-            [at!(), keyword!(_, k), ..] if k.is_keyword(keywords::Else) => {
-                self.shift(2);
-                match *self.input {
-                    [keyword!(sp, k), ..] if k.is_keyword(keywords::If) => {
-                        self.shift(1);
-                        let mut render = render.fork();
-                        self.if_expr(sp, &mut render)?;
-                        Some(render.into_stmts())
-                    },
-                    [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
-                        self.shift(1);
-                        Some(self.block(sp, d.stream(), render)?)
-                    },
-                    _ => return self.error(sp, "expected body for this @else"),
-                }
-            },
-            _ => None,
-        };
-        render.emit_if(if_cond.into_iter().collect(), if_body, else_body);
-        Ok(())
     }
 
     /// Parses and renders an `@while` expression.
     ///
     /// The leading `@while` should already be consumed.
-    fn while_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
+    fn while_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
-        let mut cond = vec![];
+        self.error("unimplemented")
-        let body;
-        loop { match *self.input {
-            [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
-                self.shift(1);
-                body = self.block(sp, d.stream(), render)?;
-                break;
-            },
-            [ref tt, ..] => {
-                self.shift(1);
-                cond.push(tt.clone());
-            },
-            [] => return self.error(sp, "expected body for this @while"),
-        }}
-        render.emit_while(cond.into_iter().collect(), body);
-        Ok(())
     }
 
     /// Parses and renders a `@for` expression.
     ///
     /// The leading `@for` should already be consumed.
-    fn for_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
+    fn for_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
-        let mut pattern = vec![];
+        self.error("unimplemented")
-        loop { match *self.input {
-            [keyword!(_, k), ..] if k.is_keyword(keywords::In) => {
-                self.shift(1);
-                break;
-            },
-            [ref tt, ..] => {
-                self.shift(1);
-                pattern.push(tt.clone());
-            },
-            _ => return self.error(sp, "invalid @for"),
-        }}
-        let mut iterable = vec![];
-        let body;
-        loop { match *self.input {
-            [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
-                self.shift(1);
-                body = self.block(sp, d.stream(), render)?;
-                break;
-            },
-            [ref tt, ..] => {
-                self.shift(1);
-                iterable.push(tt.clone());
-            },
-            _ => return self.error(sp, "invalid @for"),
-        }}
-        render.emit_for(pattern.into_iter().collect(), iterable.into_iter().collect(), body);
-        Ok(())
     }
 
     /// Parses and renders a `@match` expression.
     ///
     /// The leading `@match` should already be consumed.
-    fn match_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
+    fn match_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
-        // Parse the initial match
+        self.error("unimplemented")
-        let mut match_var = vec![];
-        let match_bodies;
-        loop { match *self.input {
-            [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
-                self.shift(1);
-                match_bodies = Parser {
-                    cx: self.cx,
-                    in_attr: self.in_attr,
-                    input: &d.stream().into_trees().collect::<Vec<_>>(),
-                    span: sp,
-                }.match_bodies(render)?;
-                break;
-            },
-            [ref tt, ..] => {
-                self.shift(1);
-                match_var.push(tt.clone());
-            },
-            [] => return self.error(sp, "expected body for this @match"),
-        }}
-        render.emit_match(match_var.into_iter().collect(), match_bodies.into_iter().collect());
-        Ok(())
     }
 
     fn match_bodies(&mut self, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> {
-        let mut bodies = Vec::new();
+        self.error("unimplemented")
-        loop { match *self.input {
-            [] => break,
-            [ref tt @ comma!(), ..] => {
-                self.shift(1);
-                bodies.push(tt.clone());
-            },
-            [ref tt, ..] => bodies.append(&mut self.match_body(tt.span(), render)?),
-        }}
-        Ok(bodies)
     }
 
-    fn match_body(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> {
+    fn match_body(&mut self, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> {
-        let mut body = vec![];
+        self.error("unimplemented")
-        loop { match *self.input {
-            [ref tt @ fat_arrow!(), ..] => {
-                self.shift(1);
-                body.push(tt.clone());
-                break;
-            },
-            [ref tt, ..] => {
-                self.shift(1);
-                body.push(tt.clone());
-            },
-            _ => return self.error(sp, "invalid @match pattern"),
-        }}
-        let mut expr = Vec::new();
-        loop { match *self.input {
-            [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
-                if expr.is_empty() {
-                    self.shift(1);
-                    expr = self.block(sp, d.stream(), render)?.into_trees().collect();
-                    break;
-                } else {
-                    self.shift(1);
-                    expr.push(TokenTree::Delimited(sp, d.clone()));
-                }
-            },
-            [comma!(), ..] | [] => {
-                if expr.is_empty() {
-                    return self.error(sp, "expected body for this @match arm");
-                } else {
-                    expr = self.block(sp, expr.into_iter().collect(), render)?.into_trees().collect();
-                    break;
-                }
-            },
-            [ref tt, ..] => {
-                self.shift(1);
-                expr.push(tt.clone());
-            },
-        }}
-        body.push(TokenTree::Delimited(sp, Delimited {
-            delim: DelimToken::Brace,
-            tts: expr.into_iter().collect::<TokenStream>().into(),
-        }));
-        Ok(body)
     }
 
     /// Parses and renders a `@let` expression.
     ///
     /// The leading `@let` should already be consumed.
-    fn let_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
+    fn let_expr(&mut self, render: &mut Renderer) -> ParseResult<()> {
-        let mut pattern = vec![];
+        self.error("unimplemented")
-        loop { match *self.input {
-            [eq!(), ..] => {
-                self.shift(1);
-                break;
-            },
-            [ref tt, ..] => {
-                self.shift(1);
-                pattern.push(tt.clone());
-            },
-            _ => return self.error(sp, "invalid @let"),
-        }}
-        let mut rhs = vec![];
-        let body;
-        loop { match *self.input {
-            [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
-                self.shift(1);
-                body = self.block(sp, d.stream(), render)?;
-                break;
-            },
-            [ref tt, ..] => {
-                self.shift(1);
-                rhs.push(tt.clone());
-            },
-            _ => return self.error(sp, "invalid @let"),
-        }}
-        render.emit_let(pattern.into_iter().collect(), rhs.into_iter().collect(), body);
-        Ok(())
     }
 
     /// Parses and renders an element node.
     ///
     /// The element name should already be consumed.
-    fn element(&mut self, sp: Span, name: &str, render: &mut Renderer) -> ParseResult<()> {
+    fn element(&mut self, name: &str, render: &mut Renderer) -> ParseResult<()> {
         if self.in_attr {
-            return self.error(sp, "unexpected element, you silly bumpkin");
+            return self.error("unexpected element, you silly bumpkin");
         }
         render.element_open_start(name);
         self.attrs(render)?;
         render.element_open_end();
-        if let [slash!(), ..] = *self.input {
+        match self.peek() {
-            self.shift(1);
+            Some(TokenNode::Op('/', _)) => {
-        } else {
+                // Void element
-            self.markup(render)?;
+                self.advance();
-            render.element_close(name);
+            },
+            _ => {
+                self.markup(render)?;
+                render.element_close(name);
+            },
         }
         Ok(())
     }
 
     /// Parses and renders the attributes of an element.
     fn attrs(&mut self, render: &mut Renderer) -> ParseResult<()> {
-        let mut classes_static = Vec::new();
+        let mut classes_static: Vec<String> = Vec::new();
-        let mut classes_toggled = Vec::new();
+        let mut classes_toggled: Vec<(TokenStream, String)> = Vec::new();
-        let mut ids = Vec::new();
+        let mut ids: Vec<String> = Vec::new();
         loop {
-            let old_input = self.input;
+            let start_position = self.input.save();
             let maybe_name = self.namespaced_name();
-            match (maybe_name, self.input) {
+            let token_after = self.next();
-                (Ok(name), &[eq!(), ..]) => {
+            match (maybe_name, token_after) {
-                    // Non-empty attribute
+                // Non-empty attribute
-                    self.shift(1);
+                (Ok(name), Some(TokenNode::Op('=', _))) => {
                     render.attribute_start(&name);
                     {
                         // Parse a value under an attribute context
-                        let mut in_attr = true;
+                        let in_attr = mem::replace(&mut self.in_attr, true);
-                        mem::swap(&mut self.in_attr, &mut in_attr);
                         self.markup(render)?;
-                        mem::swap(&mut self.in_attr, &mut in_attr);
+                        self.in_attr = in_attr;
                     }
                     render.attribute_end();
                 },
-                (Ok(name), &[question!(), ..]) => {
+                // Empty attribute
-                    // Empty attribute
+                (Ok(name), Some(TokenNode::Op('?', _))) => match self.peek() {
-                    self.shift(1);
+                    // Toggle the attribute based on a boolean expression
-                    match *self.input {
+                    Some(TokenNode::Group(Delimiter::Bracket, cond)) => {
-                        [TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Bracket => {
+                        self.advance();
-                            // Toggle the attribute based on a boolean expression
+                        let body = {
-                            self.shift(1);
+                            let mut render = render.fork();
-                            let cond = d.stream();
-                            let body = {
-                                let mut render = render.fork();
-                                render.attribute_empty(&name);
-                                render.into_stmts()
-                            };
-                            render.emit_if(cond, body, None);
-                        },
-                        _ => {
-                            // Write the attribute unconditionally
                             render.attribute_empty(&name);
-                        },
+                            render.into_stmts()
-                    }
+                        };
+                        render.emit_if(cond, body, None);
+                    },
+                    // Write the attribute unconditionally
+                    _ => render.attribute_empty(&name),
                 },
-                (Err(_), &[dot!(), ident!(_, _), ..]) => {
+                // Class shorthand
-                    // Class shorthand
+                (Err(_), Some(TokenNode::Op('.', _))) => {
-                    self.shift(1);
+                    let class_name = self.name()?;
-                    let class_name = self.name().unwrap();
+                    match self.peek() {
-                    match *self.input {
+                        // Toggle the class based on a boolean expression
-                        [TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Bracket => {
+                        Some(TokenNode::Group(Delimiter::Bracket, cond)) => {
-                            // Toggle the class based on a boolean expression
+                            self.advance();
-                            self.shift(1);
-                            let cond = d.stream();
                             classes_toggled.push((cond, class_name));
                         },
                         // Emit the class unconditionally
                         _ => classes_static.push(class_name),
                     }
                 },
-                (Err(_), &[pound!(), ident!(_, _), ..]) => {
+                // ID shorthand
-                    // ID shorthand
+                (Err(_), Some(TokenNode::Op('#', _))) => {
-                    self.shift(1);
+                    ids.push(self.name()?);
-                    ids.push(self.name().unwrap());
                 },
+                // If it's not a valid attribute, backtrack and bail out
                 _ => {
-                    self.input = old_input;
+                    self.input.restore(start_position);
                     break;
                 },
             }
@@ -511,24 +273,23 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
 
     /// Parses an identifier, without dealing with namespaces.
     fn name(&mut self) -> ParseResult<String> {
-        let mut s = match *self.input {
+        let mut s = if let Some(TokenNode::Term(term)) = self.peek() {
-            [ident!(_, name), ..] => {
+            self.advance();
-                self.shift(1);
+            String::from(term.as_str())
-                String::from(&name.name.as_str() as &str)
+        } else {
-            },
+            return self.error("expected identifier");
-            _ => return Err(()),
         };
         let mut expect_ident = false;
         loop {
-            expect_ident = match *self.input {
+            expect_ident = match self.peek() {
-                [minus!(), ..] => {
+                Some(TokenNode::Op('-', _)) => {
-                    self.shift(1);
+                    self.advance();
                     s.push('-');
                     true
                 },
-                [ident!(_, name), ..] if expect_ident => {
+                Some(TokenNode::Term(term)) if expect_ident => {
-                    self.shift(1);
+                    self.advance();
-                    s.push_str(&name.name.as_str());
+                    s.push_str(term.as_str());
                     false
                 },
                 _ => break,
@@ -541,24 +302,68 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
     /// if necessary.
     fn namespaced_name(&mut self) -> ParseResult<String> {
         let mut s = self.name()?;
-        if let [colon!(), ident!(_, _), ..] = *self.input {
+        if let Some(TokenNode::Op(':', _)) = self.peek() {
-            self.shift(1);
+            self.advance();
             s.push(':');
-            s.push_str(&self.name().unwrap());
+            s.push_str(&self.name()?);
         }
         Ok(s)
     }
 
     /// Parses the given token tree, returning a vector of statements.
-    fn block(&mut self, sp: Span, tts: TokenStream, render: &mut Renderer) -> ParseResult<TokenStream> {
+    fn block(&mut self, body: TokenStream, render: &mut Renderer) -> ParseResult<TokenStream> {
         let mut render = render.fork();
         let mut parse = Parser {
-            cx: self.cx,
             in_attr: self.in_attr,
-            input: &tts.into_trees().collect::<Vec<_>>(),
+            input: Lookahead::new(body),
-            span: sp,
         };
         parse.markups(&mut render)?;
         Ok(render.into_stmts())
     }
 }
+
+struct Lookahead<T> {
+    buffer: Vec<T>,
+    index: usize,
+}
+
+impl<T> Lookahead<T> {
+    fn new<I: IntoIterator<Item=T>>(items: I) -> Self {
+        Lookahead {
+            buffer: items.into_iter().collect(),
+            index: 0,
+        }
+    }
+
+    fn save(&self) -> Position {
+        Position { index: self.index }
+    }
+
+    fn restore(&mut self, Position { index }: Position) {
+        self.index = index;
+    }
+}
+
+impl<T> Lookahead<T> where T: Clone {
+    fn peek(&mut self) -> Option<T> {
+        let position = self.save();
+        let result = self.next();
+        self.restore(position);
+        result
+    }
+}
+
+impl<T> Iterator for Lookahead<T> where T: Clone {
+    type Item = T;
+    fn next(&mut self) -> Option<T> {
+        let result = self.buffer.get(self.index).cloned();
+        if result.is_some() {
+            self.index += 1;
+        }
+        result
+    }
+}
+
+struct Position {
+    index: usize,
+}

maud_macros/src/render.rs

@@ -1,38 +1,28 @@
-use syntax::ast::Ident;
+use proc_macro::{Literal, Term, TokenNode, TokenStream};
-use syntax::ext::base::ExtCtxt;
+use proc_macro::quote;
-use syntax::symbol::Symbol;
+use std::fmt;
-use syntax::tokenstream::{TokenStream, TokenTree};
 
-use maud::Escaper;
+pub struct Renderer {
-
+    output: TokenNode,
-// FIXME(rust-lang/rust#40939):
-// * Use `TokenStreamBuilder` instead of `Vec<TokenStream>`
-// * Use `quote!()` instead of `quote_tokens!()`
-
-pub struct Renderer<'cx, 'a: 'cx> {
-    cx: &'cx ExtCtxt<'a>,
-    writer: Ident,
     stmts: Vec<TokenStream>,
     tail: String,
 }
 
-impl<'cx, 'a> Renderer<'cx, 'a> {
+impl Renderer {
-    /// Creates a new `Renderer` using the given extension context.
+    /// Creates a new `Renderer`.
-    pub fn new(cx: &'cx ExtCtxt<'a>) -> Renderer<'cx, 'a> {
+    pub fn new() -> Renderer {
-        let writer = Ident::with_empty_ctxt(Symbol::gensym("__maud_output"));
+        let output = TokenNode::Term(Term::intern("__maud_output"));
         Renderer {
-            cx: cx,
+            output: output,
-            writer: writer,
             stmts: Vec::new(),
             tail: String::new(),
         }
     }
 
     /// Creates a new `Renderer` under the same context as `self`.
-    pub fn fork(&self) -> Renderer<'cx, 'a> {
+    pub fn fork(&self) -> Renderer {
         Renderer {
-            cx: self.cx,
+            output: self.output.clone(),
-            writer: self.writer,
             stmts: Vec::new(),
             tail: String::new(),
         }
@@ -42,36 +32,38 @@ impl<'cx, 'a> Renderer<'cx, 'a> {
     fn flush(&mut self) {
         if !self.tail.is_empty() {
             let expr = {
-                let w = self.writer;
+                let output = self.output.clone();
-                let s = &*self.tail;
+                let string = TokenNode::Literal(Literal::string(&self.tail));
-                quote_tokens!(self.cx, $w.push_str($s);)
+                quote!($output.push_str($string);)
             };
-            self.stmts.push(expr.into_iter().collect());
+            self.stmts.push(expr);
             self.tail.clear();
         }
     }
 
     /// Reifies the `Renderer` into a block of markup.
     pub fn into_expr(mut self, size_hint: usize) -> TokenStream {
-        let Renderer { cx, writer, stmts, .. } = { self.flush(); self };
+        let Renderer { output, stmts, .. } = { self.flush(); self };
-        let stmts: Vec<TokenTree> = TokenStream::concat(stmts).into_trees().collect();
+        let size_hint = TokenNode::Literal(Literal::u64(size_hint as u64));
-        quote_tokens!(cx, {
+        let stmts = stmts.into_iter().collect::<TokenStream>();
-            let mut $writer = ::std::string::String::with_capacity($size_hint);
+        quote!({
+            extern crate maud;
+            let mut $output = String::with_capacity($size_hint as usize);
             $stmts
-            ::maud::PreEscaped($writer)
+            maud::PreEscaped($output)
-        }).into_iter().collect()
+        })
     }
 
     /// Reifies the `Renderer` into a raw list of statements.
     pub fn into_stmts(mut self) -> TokenStream {
         let Renderer { stmts, .. } = { self.flush(); self };
-        TokenStream::concat(stmts)
+        stmts.into_iter().collect()
     }
 
     /// Pushes a statement, flushing the tail buffer in the process.
-    fn push<T>(&mut self, stmt: T) where T: IntoIterator<Item=TokenTree> {
+    fn push<T>(&mut self, stmt: T) where T: Into<TokenStream> {
         self.flush();
-        self.stmts.push(stmt.into_iter().collect())
+        self.stmts.push(stmt.into())
     }
 
     /// Pushes a literal string to the tail buffer.
@@ -86,12 +78,17 @@ impl<'cx, 'a> Renderer<'cx, 'a> {
 
     /// Appends the result of an expression.
     pub fn splice(&mut self, expr: TokenStream) {
-        let w = self.writer;
+        let output = self.output.clone();
-        let expr: Vec<TokenTree> = expr.into_trees().collect();
+        self.push(quote!({
-        self.push(quote_tokens!(self.cx, {
+            extern crate maud;
-            #[allow(unused_imports)]
+            // Create a local trait alias so that autoref works
-            use ::maud::Render as __maud_Render;
+            trait Render: maud::Render {
-            $expr.render_to(&mut $w);
+                fn render_to(&self, output: &mut String) {
+                    maud::Render::render_to(self, output);
+                }
+            }
+            impl<T: maud::Render> Render for T {}
+            $expr.render_to(&mut $output);
         }));
     }
 
@@ -131,14 +128,9 @@ impl<'cx, 'a> Renderer<'cx, 'a> {
     /// need to special-case `if let`.
     pub fn emit_if(&mut self, if_cond: TokenStream, if_body: TokenStream,
                    else_body: Option<TokenStream>) {
-        let if_cond: Vec<TokenTree> = if_cond.into_trees().collect();
-        let if_body: Vec<TokenTree> = if_body.into_trees().collect();
         let stmt = match else_body {
-            None => quote_tokens!(self.cx, if $if_cond { $if_body }),
+            None => quote!(if $if_cond { $if_body }),
-            Some(else_body) => {
+            Some(else_body) => quote!(if $if_cond { $if_body } else { $else_body }),
-                let else_body: Vec<TokenTree> = else_body.into_trees().collect();
-                quote_tokens!(self.cx, if $if_cond { $if_body } else { $else_body })
-            },
         };
         self.push(stmt);
     }
@@ -148,32 +140,22 @@ impl<'cx, 'a> Renderer<'cx, 'a> {
     /// The condition is a token tree (not an expression) so we don't
     /// need to special-case `while let`.
     pub fn emit_while(&mut self, cond: TokenStream, body: TokenStream) {
-        let cond: Vec<TokenTree> = cond.into_trees().collect();
+        let stmt = quote!(while $cond { $body });
-        let body: Vec<TokenTree> = body.into_trees().collect();
-        let stmt = quote_tokens!(self.cx, while $cond { $body });
         self.push(stmt);
     }
 
     pub fn emit_for(&mut self, pattern: TokenStream, iterable: TokenStream, body: TokenStream) {
-        let pattern: Vec<TokenTree> = pattern.into_trees().collect();
+        let stmt = quote!(for $pattern in $iterable { $body });
-        let iterable: Vec<TokenTree> = iterable.into_trees().collect();
-        let body: Vec<TokenTree> = body.into_trees().collect();
-        let stmt = quote_tokens!(self.cx, for $pattern in $iterable { $body });
         self.push(stmt);
     }
 
     pub fn emit_match(&mut self, match_var: TokenStream, match_body: TokenStream) {
-        let match_var: Vec<TokenTree> = match_var.into_trees().collect();
+        let stmt = quote!(match $match_var { $match_body });
-        let match_body: Vec<TokenTree> = match_body.into_trees().collect();
-        let stmt = quote_tokens!(self.cx, match $match_var { $match_body });
         self.push(stmt);
     }
 
     pub fn emit_let(&mut self, pattern: TokenStream, rhs: TokenStream, body: TokenStream) {
-        let pattern: Vec<TokenTree> = pattern.into_trees().collect();
+        let stmt = quote!({ let $pattern = $rhs; $body });
-        let rhs: Vec<TokenTree> = rhs.into_trees().collect();
-        let body: Vec<TokenTree> = body.into_trees().collect();
-        let stmt = quote_tokens!(self.cx, { let $pattern = $rhs; $body });
         self.push(stmt);
     }
 }
@@ -184,3 +166,28 @@ fn html_escape(s: &str) -> String {
     Escaper::new(&mut buffer).write_str(s).unwrap();
     buffer
 }
+
+// TODO move this into a common `maud_htmlescape` crate
+struct Escaper<'a>(&'a mut String);
+
+impl<'a> Escaper<'a> {
+    /// Creates an `Escaper` from a `String`.
+    pub fn new(buffer: &'a mut String) -> Escaper<'a> {
+        Escaper(buffer)
+    }
+}
+
+impl<'a> fmt::Write for Escaper<'a> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for b in s.bytes() {
+            match b {
+                b'&' => self.0.push_str("&amp;"),
+                b'<' => self.0.push_str("&lt;"),
+                b'>' => self.0.push_str("&gt;"),
+                b'"' => self.0.push_str("&quot;"),
+                _ => unsafe { self.0.as_mut_vec().push(b) },
+            }
+        }
+        Ok(())
+    }
+}