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

Use the new ? syntax (so purty)

Browse source
This commit is contained in:
Chris Wong 2016-03-22 23:31:23 +13:00
parent 28c965ac72
commit 8492259638
2 changed files with 37 additions and 36 deletions
maud_macros/src
lib.rsparse.rs

7
maud_macros/src/lib.rs
View file

@ -1,5 +1,6 @@
#![crate_type = "dylib"] #![crate_type = "dylib"]
#![feature(plugin_registrar, quote)] #![feature(plugin_registrar, quote)]
#![feature(question_mark)]
#![feature(slice_patterns)] #![feature(slice_patterns)]
#![feature(rustc_private)] #![feature(rustc_private)]
@ -22,17 +23,17 @@ mod render;
pub type PResult<T> = Result<T, FatalError>; pub type PResult<T> = Result<T, FatalError>;
fn html(cx: &mut ExtCtxt, sp: Span, mac_name: &str, args: &[TokenTree]) -> PResult<P<Expr>> { fn html(cx: &mut ExtCtxt, sp: Span, mac_name: &str, args: &[TokenTree]) -> PResult<P<Expr>> {
let (write, input) = try!(parse::split_comma(cx, sp, mac_name, args)); let (write, input) = parse::split_comma(cx, sp, mac_name, args)?;
parse::parse(cx, sp, write, input) parse::parse(cx, sp, write, input)
} }
fn html_utf8(cx: &mut ExtCtxt, sp: Span, mac_name: &str, args: &[TokenTree]) -> PResult<P<Expr>> { fn html_utf8(cx: &mut ExtCtxt, sp: Span, mac_name: &str, args: &[TokenTree]) -> PResult<P<Expr>> {
let (io_write, input) = try!(parse::split_comma(cx, sp, mac_name, args)); let (io_write, input) = parse::split_comma(cx, sp, mac_name, args)?;
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![
TokenTree::Token(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 = 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) {
mut $fmt_write => { mut $fmt_write => {

66
maud_macros/src/parse.rs
View file

@ -85,7 +85,7 @@ pub fn parse(cx: &ExtCtxt, sp: Span, write: &[TokenTree], input: &[TokenTree])
span: sp, span: sp,
render: Renderer::new(cx), render: Renderer::new(cx),
}; };
try!(parser.markups()); parser.markups()?;
Ok(parser.into_render().into_expr(write.to_vec())) Ok(parser.into_render().into_expr(write.to_vec()))
} }
@ -145,7 +145,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
match self.input { match self.input {
[] => return Ok(()), [] => return Ok(()),
[semi!(), ..] => self.shift(1), [semi!(), ..] => self.shift(1),
[_, ..] => try!(self.markup()), [_, ..] => self.markup()?,
} }
} }
} }
@ -156,43 +156,43 @@ impl<'cx, 'i> Parser<'cx, 'i> {
// Literal // Literal
[minus!(), ref tt @ literal!(), ..] => { [minus!(), ref tt @ literal!(), ..] => {
self.shift(2); self.shift(2);
try!(self.literal(tt, true)); self.literal(tt, true)?;
}, },
[ref tt @ literal!(), ..] => { [ref tt @ literal!(), ..] => {
self.shift(1); self.shift(1);
try!(self.literal(tt, false)) self.literal(tt, false)?;
}, },
// If // If
[at!(), keyword!(sp, k), ..] if k.is_keyword(Keyword::If) => { [at!(), keyword!(sp, k), ..] if k.is_keyword(Keyword::If) => {
self.shift(2); self.shift(2);
try!(self.if_expr(sp)); self.if_expr(sp)?;
}, },
// For // For
[at!(), keyword!(sp, k), ..] if k.is_keyword(Keyword::For) => { [at!(), keyword!(sp, k), ..] if k.is_keyword(Keyword::For) => {
self.shift(2); self.shift(2);
try!(self.for_expr(sp)); self.for_expr(sp)?;
}, },
// Match // Match
[at!(), keyword!(sp, k), ..] if k.is_keyword(Keyword::Match) => { [at!(), keyword!(sp, k), ..] if k.is_keyword(Keyword::Match) => {
self.shift(2); self.shift(2);
try!(self.match_expr(sp)); self.match_expr(sp)?;
}, },
// Call // Call
[at!(), ident!(sp, name), ..] if name.name.as_str() == "call" => { [at!(), ident!(sp, name), ..] if name.name.as_str() == "call" => {
self.shift(2); self.shift(2);
let func = try!(self.splice(sp)); let func = self.splice(sp)?;
self.render.emit_call(func); self.render.emit_call(func);
}, },
// Splice // Splice
[ref tt @ caret!(), ..] => { [ref tt @ caret!(), ..] => {
self.shift(1); self.shift(1);
let expr = try!(self.splice(tt.get_span())); let expr = self.splice(tt.get_span())?;
self.render.splice(expr); self.render.splice(expr);
}, },
// Element // Element
[ident!(sp, _), ..] => { [ident!(sp, _), ..] => {
let name = try!(self.name()); let name = self.name()?;
try!(self.element(sp, &name)); self.element(sp, &name)?;
}, },
// Block // Block
[TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Brace => { [TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Brace => {
@ -202,7 +202,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
// result inline // result inline
let mut i = &*d.tts; let mut i = &*d.tts;
mem::swap(&mut self.input, &mut i); mem::swap(&mut self.input, &mut i);
try!(self.markups()); self.markups()?;
mem::swap(&mut self.input, &mut i); mem::swap(&mut self.input, &mut i);
} }
}, },
@ -220,8 +220,8 @@ impl<'cx, 'i> Parser<'cx, 'i> {
/// Parses and renders a literal string or number. /// Parses and renders a literal string or number.
fn literal(&mut self, tt: &TokenTree, minus: bool) -> PResult<()> { fn literal(&mut self, tt: &TokenTree, minus: bool) -> PResult<()> {
let lit = try!(self.with_rust_parser(vec![tt.clone()], RustParser::parse_lit)); let lit = self.with_rust_parser(vec![tt.clone()], RustParser::parse_lit)?;
let s = try!(lit_to_string(self.render.cx, lit, minus)); let s = lit_to_string(self.render.cx, lit, minus)?;
self.render.string(&s); self.render.string(&s);
Ok(()) Ok(())
} }
@ -236,7 +236,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
loop { match self.input { loop { match self.input {
[TokenTree::Delimited(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 = self.block(sp, &d.tts)?;
break; break;
}, },
[ref tt, ..] => { [ref tt, ..] => {
@ -257,7 +257,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
// rather than emitting it right away // rather than emitting it right away
let mut r = self.render.fork(); let mut r = self.render.fork();
mem::swap(&mut self.render, &mut r); mem::swap(&mut self.render, &mut r);
try!(self.if_expr(sp)); self.if_expr(sp)?;
mem::swap(&mut self.render, &mut r); mem::swap(&mut self.render, &mut r);
r.into_stmts() r.into_stmts()
}; };
@ -265,7 +265,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
}, },
[TokenTree::Delimited(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(self.block(sp, &d.tts)?)
}, },
_ => parse_error!(self, sp, "expected body for this @else"), _ => parse_error!(self, sp, "expected body for this @else"),
} }
@ -292,13 +292,13 @@ impl<'cx, 'i> Parser<'cx, 'i> {
}, },
_ => parse_error!(self, sp, "invalid @for"), _ => parse_error!(self, sp, "invalid @for"),
}} }}
let pattern = try!(self.with_rust_parser(pattern, RustParser::parse_pat)); let pattern = self.with_rust_parser(pattern, RustParser::parse_pat)?;
let mut iterable = vec![]; let mut iterable = vec![];
let body; let body;
loop { match self.input { loop { match self.input {
[TokenTree::Delimited(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 = self.block(sp, &d.tts)?;
break; break;
}, },
[ref tt, ..] => { [ref tt, ..] => {
@ -307,7 +307,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
}, },
_ => parse_error!(self, sp, "invalid @for"), _ => parse_error!(self, sp, "invalid @for"),
}} }}
let iterable = try!(self.with_rust_parser(iterable, RustParser::parse_expr)); let iterable = self.with_rust_parser(iterable, RustParser::parse_expr)?;
self.render.emit_for(pattern, iterable, body); self.render.emit_for(pattern, iterable, body);
Ok(()) Ok(())
} }
@ -322,12 +322,12 @@ impl<'cx, 'i> Parser<'cx, 'i> {
loop { match self.input { loop { match self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1); self.shift(1);
match_bodies = try!(Parser { match_bodies = Parser {
in_attr: self.in_attr, in_attr: self.in_attr,
input: &d.tts, input: &d.tts,
span: sp, span: sp,
render: self.render.fork(), render: self.render.fork(),
}.match_bodies()); }.match_bodies()?;
break; break;
}, },
[ref tt, ..] => { [ref tt, ..] => {
@ -336,7 +336,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
}, },
[] => parse_error!(self, sp, "expected body for this @match"), [] => parse_error!(self, sp, "expected body for this @match"),
}} }}
let match_var = try!(self.with_rust_parser(match_var, RustParser::parse_expr)); let match_var = self.with_rust_parser(match_var, RustParser::parse_expr)?;
self.render.emit_match(match_var, match_bodies); self.render.emit_match(match_var, match_bodies);
Ok(()) Ok(())
} }
@ -351,7 +351,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
bodies.push(tt.clone()); bodies.push(tt.clone());
}, },
[TokenTree::Token(sp, _), ..] | [TokenTree::Delimited(sp, _), ..] | [TokenTree::Sequence(sp, _), ..] => { [TokenTree::Token(sp, _), ..] | [TokenTree::Delimited(sp, _), ..] | [TokenTree::Sequence(sp, _), ..] => {
bodies.append(&mut try!(self.match_body(sp))); bodies.append(&mut self.match_body(sp)?);
}, },
} }
} }
@ -377,7 +377,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => { [TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
if expr.is_empty() { if expr.is_empty() {
self.shift(1); self.shift(1);
expr = try!(self.block(sp, &d.tts)).to_tokens(self.render.cx); expr = self.block(sp, &d.tts)?.to_tokens(self.render.cx);
break; break;
} else { } else {
self.shift(1); self.shift(1);
@ -388,7 +388,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
if expr.is_empty() { if expr.is_empty() {
parse_error!(self, sp, "expected body for this @match arm"); parse_error!(self, sp, "expected body for this @match arm");
} else { } else {
expr = try!(self.block(sp, &expr)).to_tokens(self.render.cx); expr = self.block(sp, &expr)?.to_tokens(self.render.cx);
break; break;
} }
}, },
@ -462,13 +462,13 @@ impl<'cx, 'i> Parser<'cx, 'i> {
parse_error!(self, sp, "unexpected element, you silly bumpkin"); parse_error!(self, sp, "unexpected element, you silly bumpkin");
} }
self.render.element_open_start(name); self.render.element_open_start(name);
try!(self.class_shorthand()); self.class_shorthand()?;
try!(self.attrs()); self.attrs()?;
self.render.element_open_end(); self.render.element_open_end();
if let [slash!(), ..] = self.input { if let [slash!(), ..] = self.input {
self.shift(1); self.shift(1);
} else { } else {
try!(self.markup()); self.markup()?;
self.render.element_close(name); self.render.element_close(name);
} }
Ok(()) Ok(())
@ -479,7 +479,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
let mut classes = Vec::new(); let mut classes = Vec::new();
while let [dot!(), ident!(_, _), ..] = self.input { while let [dot!(), ident!(_, _), ..] = self.input {
self.shift(1); self.shift(1);
classes.push(try!(self.name())); classes.push(self.name()?);
} }
if !classes.is_empty() { if !classes.is_empty() {
self.render.attribute_start("class"); self.render.attribute_start("class");
@ -503,7 +503,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
// Parse a value under an attribute context // Parse a value under an attribute context
let mut in_attr = true; let mut in_attr = true;
mem::swap(&mut self.in_attr, &mut in_attr); mem::swap(&mut self.in_attr, &mut in_attr);
try!(self.markup()); self.markup()?;
mem::swap(&mut self.in_attr, &mut in_attr); mem::swap(&mut self.in_attr, &mut in_attr);
} }
self.render.attribute_end(); self.render.attribute_end();
@ -514,7 +514,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
if let [ref tt @ eq!(), ..] = self.input { if let [ref tt @ eq!(), ..] = self.input {
// Toggle the attribute based on a boolean expression // Toggle the attribute based on a boolean expression
self.shift(1); self.shift(1);
let cond = try!(self.splice(tt.get_span())); let cond = self.splice(tt.get_span())?;
// Silence "unnecessary parentheses" warnings // Silence "unnecessary parentheses" warnings
let cond = strip_outer_parens(cond).to_tokens(self.render.cx); let cond = strip_outer_parens(cond).to_tokens(self.render.cx);
let body = { let body = {
@ -561,7 +561,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
span: sp, span: sp,
render: self.render.fork(), render: self.render.fork(),
}; };
try!(parse.markups()); parse.markups()?;
Ok(parse.into_render().into_stmts()) Ok(parse.into_render().into_stmts())
} }
} }