maud/maud_macros/src/parse.rs

use std::mem;
use syntax::ast::LitKind;
use syntax::codemap::Span;
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 {
    () => (TokenTree::Token(_, Token::At))
}
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,
        span: sp,
    }.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();
    Ok(render.into_expr(size_hint).into_trees().collect())
}

struct Parser<'cx, 'a: 'cx, 'i> {
    cx: &'cx ExtCtxt<'a>,
    in_attr: bool,
    input: &'i [TokenTree],
    span: Span,
}

impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
    /// Consumes `n` items from the input.
    fn shift(&mut self, n: usize) {
        self.input = &self.input[n..];
    }

    /// Attaches an error message to the span and returns `Err`.
    fn error<T>(&self, span: Span, message: &str) -> ParseResult<T> {
        self.cx.span_err(span, message);
        Err(())
    }

    /// Parses and renders multiple blocks of markup.
    fn markups(&mut self, render: &mut Renderer) -> ParseResult<()> {
        loop {
            match *self.input {
                [] => return Ok(()),
                [semi!(), ..] => self.shift(1),
                [_, ..] => self.markup(render)?,
            }
        }
    }

    /// Parses and renders a single block of markup.
    fn markup(&mut self, render: &mut Renderer) -> ParseResult<()> {
        match *self.input {
            // Literal
            [ref tt @ literal!(), ..] => {
                self.shift(1);
                self.literal(tt, render)?;
            },
            // If
            [at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::If) => {
                self.shift(2);
                self.if_expr(sp, render)?;
            },
            // While
            [at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::While) => {
                self.shift(2);
                self.while_expr(sp, render)?;
            },
            // For
            [at!(), keyword!(sp, k), ..] if k.is_keyword(keywords::For) => {
                self.shift(2);
                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, _), ..] => {
                let name = self.namespaced_name().unwrap();
                self.element(sp, &name, render)?;
            },
            // Splice
            [TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Paren => {
                self.shift(1);
                render.splice(d.stream());
            }
            // Block
            [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
                self.shift(1);
                Parser {
                    cx: self.cx,
                    in_attr: self.in_attr,
                    input: &d.stream().into_trees().collect::<Vec<_>>(),
                    span: sp,
                }.markups(render)?;
            },
            // ???
            _ => {
                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<()> {
        let mut rust_parser = parse::stream_to_parser(self.cx.parse_sess, tt.clone().into());
        let lit = rust_parser.parse_lit().map_err(|mut e| e.emit())?;
        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\")")
        }
    }

    /// Parses and renders an `@if` expression.
    ///
    /// The leading `@if` should already be consumed.
    fn if_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
        // Parse the initial if
        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<()> {
        let mut cond = 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);
                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<()> {
        let mut pattern = vec![];
        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<()> {
        // Parse the initial match
        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();
        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>> {
        let mut body = vec![];
        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<()> {
        let mut pattern = vec![];
        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<()> {
        if self.in_attr {
            return self.error(sp, "unexpected element, you silly bumpkin");
        }
        render.element_open_start(name);
        self.attrs(render)?;
        render.element_open_end();
        if let [slash!(), ..] = *self.input {
            self.shift(1);
        } else {
            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_toggled = Vec::new();
        let mut ids = Vec::new();
        loop {
            let old_input = self.input;
            let maybe_name = self.namespaced_name();
            match (maybe_name, self.input) {
                (Ok(name), &[eq!(), ..]) => {
                    // Non-empty attribute
                    self.shift(1);
                    render.attribute_start(&name);
                    {
                        // Parse a value under an attribute context
                        let mut in_attr = true;
                        mem::swap(&mut self.in_attr, &mut in_attr);
                        self.markup(render)?;
                        mem::swap(&mut self.in_attr, &mut in_attr);
                    }
                    render.attribute_end();
                },
                (Ok(name), &[question!(), ..]) => {
                    // Empty attribute
                    self.shift(1);
                    match *self.input {
                        [TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Bracket => {
                            // Toggle the attribute based on a boolean expression
                            self.shift(1);
                            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);
                        },
                    }
                },
                (Err(_), &[dot!(), ident!(_, _), ..]) => {
                    // Class shorthand
                    self.shift(1);
                    let class_name = self.name().unwrap();
                    match *self.input {
                        [TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Bracket => {
                            // Toggle the class based on a boolean expression
                            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
                    self.shift(1);
                    ids.push(self.name().unwrap());
                },
                _ => {
                    self.input = old_input;
                    break;
                },
            }
        }
        if !classes_static.is_empty() || !classes_toggled.is_empty() {
            render.attribute_start("class");
            render.string(&classes_static.join(" "));
            for (i, (cond, mut class_name)) in classes_toggled.into_iter().enumerate() {
                // If a class comes first in the list, then it shouldn't be
                // prefixed by a space
                if i > 0 || !classes_static.is_empty() {
                    class_name = format!(" {}", class_name);
                }
                let body = {
                    let mut render = render.fork();
                    render.string(&class_name);
                    render.into_stmts()
                };
                render.emit_if(cond, body, None);
            }
            render.attribute_end();
        }
        if !ids.is_empty() {
            render.attribute_start("id");
            render.string(&ids.join(" "));
            render.attribute_end();
        }
        Ok(())
    }

    /// Parses an identifier, without dealing with namespaces.
    fn name(&mut self) -> ParseResult<String> {
        let mut s = match *self.input {
            [ident!(_, name), ..] => {
                self.shift(1);
                String::from(&name.name.as_str() as &str)
            },
            _ => return Err(()),
        };
        let mut expect_ident = false;
        loop {
            expect_ident = match *self.input {
                [minus!(), ..] => {
                    self.shift(1);
                    s.push('-');
                    true
                },
                [ident!(_, name), ..] if expect_ident => {
                    self.shift(1);
                    s.push_str(&name.name.as_str());
                    false
                },
                _ => break,
            };
        }
        Ok(s)
    }

    /// Parses a HTML element or attribute name, along with a namespace
    /// if necessary.
    fn namespaced_name(&mut self) -> ParseResult<String> {
        let mut s = self.name()?;
        if let [colon!(), ident!(_, _), ..] = *self.input {
            self.shift(1);
            s.push(':');
            s.push_str(&self.name().unwrap());
        }
        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> {
        let mut render = render.fork();
        let mut parse = Parser {
            cx: self.cx,
            in_attr: self.in_attr,
            input: &tts.into_trees().collect::<Vec<_>>(),
            span: sp,
        };
        parse.markups(&mut render)?;
        Ok(render.into_stmts())
    }
}