badmanners/maud
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Update Rust

Browse source
This commit is contained in:
Chris Wong 2015-11-08 18:59:11 +13:00
parent 34f14dd41d
commit 05b5d099fb
3 changed files with 29 additions and 29 deletions

4
maud_macros/src/lib.rs
View file

@ -7,7 +7,7 @@ extern crate syntax;
extern crate rustc; extern crate rustc;
extern crate maud; extern crate maud;
use syntax::ast::{Expr, TokenTree, TtToken}; use syntax::ast::{Expr, TokenTree};
use syntax::codemap::{DUMMY_SP, Span}; use syntax::codemap::{DUMMY_SP, Span};
use syntax::ext::base::{DummyResult, ExtCtxt, MacEager, MacResult}; use syntax::ext::base::{DummyResult, ExtCtxt, MacEager, MacResult};
use syntax::parse::{token, PResult}; use syntax::parse::{token, PResult};
@ -28,7 +28,7 @@ fn html_utf8(cx: &mut ExtCtxt, sp: Span, mac_name: &str, args: &[TokenTree]) ->
let io_write = io_write.to_vec(); let io_write = io_write.to_vec();
let fmt_write = token::gensym_ident("__maud_utf8_writer"); let fmt_write = token::gensym_ident("__maud_utf8_writer");
let fmt_write = vec![ let fmt_write = vec![
TtToken(DUMMY_SP, token::Ident(fmt_write, token::IdentStyle::Plain))]; TokenTree::Token(DUMMY_SP, token::Ident(fmt_write, token::IdentStyle::Plain))];
let expr = try!(parse::parse(cx, sp, &fmt_write, input)); let expr = try!(parse::parse(cx, sp, &fmt_write, input));
Ok(quote_expr!(cx, Ok(quote_expr!(cx,
match ::maud::Utf8Writer::new(&mut $io_write) { match ::maud::Utf8Writer::new(&mut $io_write) {

50
maud_macros/src/parse.rs
View file

@ -1,5 +1,5 @@
use std::mem; use std::mem;
use syntax::ast::{Expr, ExprParen, Lit, Stmt, TokenTree, TtDelimited, TtToken}; use syntax::ast::{Expr, ExprParen, Lit, Stmt, TokenTree};
use syntax::ext::quote::rt::ToTokens; use syntax::ext::quote::rt::ToTokens;
use syntax::codemap::Span; use syntax::codemap::Span;
use syntax::diagnostic::FatalError; use syntax::diagnostic::FatalError;
@ -23,43 +23,43 @@ macro_rules! parse_error {
} }
macro_rules! dollar { macro_rules! dollar {
() => (TtToken(_, Token::Dollar)) () => (TokenTree::Token(_, Token::Dollar))
} }
macro_rules! pound { macro_rules! pound {
() => (TtToken(_, Token::Pound)) () => (TokenTree::Token(_, Token::Pound))
} }
macro_rules! dot { macro_rules! dot {
() => (TtToken(_, Token::Dot)) () => (TokenTree::Token(_, Token::Dot))
} }
macro_rules! eq { macro_rules! eq {
() => (TtToken(_, Token::Eq)) () => (TokenTree::Token(_, Token::Eq))
} }
macro_rules! not { macro_rules! not {
() => (TtToken(_, Token::Not)) () => (TokenTree::Token(_, Token::Not))
} }
macro_rules! question { macro_rules! question {
() => (TtToken(_, Token::Question)) () => (TokenTree::Token(_, Token::Question))
} }
macro_rules! semi { macro_rules! semi {
() => (TtToken(_, Token::Semi)) () => (TokenTree::Token(_, Token::Semi))
} }
macro_rules! minus { macro_rules! minus {
() => (TtToken(_, Token::BinOp(BinOpToken::Minus))) () => (TokenTree::Token(_, Token::BinOp(BinOpToken::Minus)))
} }
macro_rules! slash { macro_rules! slash {
() => (TtToken(_, Token::BinOp(BinOpToken::Slash))) () => (TokenTree::Token(_, Token::BinOp(BinOpToken::Slash)))
} }
macro_rules! literal { macro_rules! literal {
() => (TtToken(_, Token::Literal(..))) () => (TokenTree::Token(_, Token::Literal(..)))
} }
macro_rules! ident { macro_rules! ident {
($sp:pat, $x:pat) => (TtToken($sp, Token::Ident($x, IdentStyle::Plain))) ($sp:pat, $x:pat) => (TokenTree::Token($sp, Token::Ident($x, IdentStyle::Plain)))
} }
macro_rules! substnt { macro_rules! substnt {
($sp:pat, $x:pat) => (TtToken($sp, Token::SubstNt($x, IdentStyle::Plain))) ($sp:pat, $x:pat) => (TokenTree::Token($sp, Token::SubstNt($x, IdentStyle::Plain)))
} }
macro_rules! keyword { macro_rules! keyword {
($sp:pat, $x:ident) => (TtToken($sp, ref $x @ Token::Ident(..))) ($sp:pat, $x:ident) => (TokenTree::Token($sp, ref $x @ Token::Ident(..)))
} }
pub fn parse(cx: &ExtCtxt, sp: Span, write: &[TokenTree], input: &[TokenTree]) pub fn parse(cx: &ExtCtxt, sp: Span, write: &[TokenTree], input: &[TokenTree])
@ -80,7 +80,7 @@ pub fn split_comma<'a>(cx: &ExtCtxt, sp: Span, mac_name: &str, args: &'a [TokenT
{ {
fn is_comma(t: &TokenTree) -> bool { fn is_comma(t: &TokenTree) -> bool {
match *t { match *t {
TtToken(_, Token::Comma) => true, TokenTree::Token(_, Token::Comma) => true,
_ => false, _ => false,
} }
} }
@ -174,7 +174,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
self.shift(1); self.shift(1);
// Parse `SubstNt` as `[Dollar, Ident]` // Parse `SubstNt` as `[Dollar, Ident]`
// See <https://github.com/lfairy/maud/issues/23> // See <https://github.com/lfairy/maud/issues/23>
let prefix = TtToken(sp, Token::Ident(ident, IdentStyle::Plain)); let prefix = TokenTree::Token(sp, Token::Ident(ident, IdentStyle::Plain));
let expr = try!(self.splice_with_prefix(prefix)); let expr = try!(self.splice_with_prefix(prefix));
self.render.splice(expr); self.render.splice(expr);
}, },
@ -184,7 +184,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
try!(self.element(sp, &name)); try!(self.element(sp, &name));
}, },
// Block // Block
[TtDelimited(_, ref d), ..] if d.delim == DelimToken::Brace => { [TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1); self.shift(1);
{ {
// Parse the contents of the block, emitting the // Parse the contents of the block, emitting the
@ -223,7 +223,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
let mut if_cond = vec![]; let mut if_cond = vec![];
let if_body; let if_body;
loop { match self.input { loop { match self.input {
[TtDelimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1); self.shift(1);
if_body = try!(self.block(sp, &d.tts)); if_body = try!(self.block(sp, &d.tts));
break; break;
@ -252,7 +252,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
}; };
Some(else_body) Some(else_body)
}, },
[TtDelimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1); self.shift(1);
Some(try!(self.block(sp, &d.tts))) Some(try!(self.block(sp, &d.tts)))
}, },
@ -281,11 +281,11 @@ impl<'cx, 'i> Parser<'cx, 'i> {
}, },
_ => parse_error!(self, sp, "invalid #for"), _ => parse_error!(self, sp, "invalid #for"),
}} }}
let pattern = self.with_rust_parser(pattern, RustParser::parse_pat); let pattern = try!(self.with_rust_parser(pattern, RustParser::parse_pat_nopanic));
let mut iterable = vec![]; let mut iterable = vec![];
let body; let body;
loop { match self.input { loop { match self.input {
[TtDelimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1); self.shift(1);
body = try!(self.block(sp, &d.tts)); body = try!(self.block(sp, &d.tts));
break; break;
@ -296,7 +296,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
}, },
_ => parse_error!(self, sp, "invalid #for"), _ => parse_error!(self, sp, "invalid #for"),
}} }}
let iterable = self.with_rust_parser(iterable, RustParser::parse_expr); let iterable = try!(self.with_rust_parser(iterable, RustParser::parse_expr_nopanic));
self.render.emit_for(pattern, iterable, body); self.render.emit_for(pattern, iterable, body);
Ok(()) Ok(())
} }
@ -328,13 +328,13 @@ impl<'cx, 'i> Parser<'cx, 'i> {
tts.push(ident.clone()); tts.push(ident.clone());
}, },
// Munch function calls `()` and indexing operations `[]` // Munch function calls `()` and indexing operations `[]`
[TtDelimited(sp, ref d), ..] if d.delim != DelimToken::Brace => { [TokenTree::Delimited(sp, ref d), ..] if d.delim != DelimToken::Brace => {
self.shift(1); self.shift(1);
tts.push(TtDelimited(sp, d.clone())); tts.push(TokenTree::Delimited(sp, d.clone()));
}, },
_ => break, _ => break,
}} }}
Ok(self.with_rust_parser(tts, RustParser::parse_expr)) self.with_rust_parser(tts, RustParser::parse_expr_nopanic)
} }
/// Parses and renders an element node. /// Parses and renders an element node.

4
maud_macros/src/render.rs
View file

@ -1,5 +1,5 @@
use std::fmt::Write; use std::fmt::Write;
use syntax::ast::{Expr, Ident, Pat, Stmt, TokenTree, TtToken}; use syntax::ast::{Expr, Ident, Pat, Stmt, TokenTree};
use syntax::codemap::DUMMY_SP; use syntax::codemap::DUMMY_SP;
use syntax::ext::base::ExtCtxt; use syntax::ext::base::ExtCtxt;
use syntax::parse::token; use syntax::parse::token;
@ -26,7 +26,7 @@ impl<'cx> Renderer<'cx> {
cx: cx, cx: cx,
writer: writer, writer: writer,
result: result, result: result,
loop_label: vec![TtToken(DUMMY_SP, token::Lifetime(loop_label))], loop_label: vec![TokenTree::Token(DUMMY_SP, token::Lifetime(loop_label))],
stmts: vec![], stmts: vec![],
tail: String::new(), tail: String::new(),
} }