From 8492259638e10742f4fd2951e5a169b2aee50e05 Mon Sep 17 00:00:00 2001
From: Chris Wong <lambda.fairy@gmail.com>
Date: Tue, 22 Mar 2016 23:31:23 +1300
Subject: [PATCH] Use the new `?` syntax (so purty)
---
maud_macros/src/lib.rs | 7 +++--
maud_macros/src/parse.rs | 66 ++++++++++++++++++++--------------------
2 files changed, 37 insertions(+), 36 deletions(-)
diff --git a/maud_macros/src/lib.rs b/maud_macros/src/lib.rs
index 87a4270..20791cc 100644
--- a/maud_macros/src/lib.rs
+++ b/maud_macros/src/lib.rs
@@ -1,5 +1,6 @@
#![crate_type = "dylib"]
#![feature(plugin_registrar, quote)]
+#![feature(question_mark)]
#![feature(slice_patterns)]
#![feature(rustc_private)]
@@ -22,17 +23,17 @@ mod render;
pub type PResult<T> = Result<T, FatalError>;
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)
}
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 fmt_write = token::gensym_ident("__maud_utf8_writer");
let fmt_write = vec![
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,
match ::maud::Utf8Writer::new(&mut $io_write) {
mut $fmt_write => {
diff --git a/maud_macros/src/parse.rs b/maud_macros/src/parse.rs
index 33adedb..679f377 100644
--- a/maud_macros/src/parse.rs
+++ b/maud_macros/src/parse.rs
@@ -85,7 +85,7 @@ pub fn parse(cx: &ExtCtxt, sp: Span, write: &[TokenTree], input: &[TokenTree])
span: sp,
render: Renderer::new(cx),
};
- try!(parser.markups());
+ parser.markups()?;
Ok(parser.into_render().into_expr(write.to_vec()))
}
@@ -145,7 +145,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
match self.input {
[] => return Ok(()),
[semi!(), ..] => self.shift(1),
- [_, ..] => try!(self.markup()),
+ [_, ..] => self.markup()?,
}
}
}
@@ -156,43 +156,43 @@ impl<'cx, 'i> Parser<'cx, 'i> {
// Literal
[minus!(), ref tt @ literal!(), ..] => {
self.shift(2);
- try!(self.literal(tt, true));
+ self.literal(tt, true)?;
},
[ref tt @ literal!(), ..] => {
self.shift(1);
- try!(self.literal(tt, false))
+ self.literal(tt, false)?;
},
// If
[at!(), keyword!(sp, k), ..] if k.is_keyword(Keyword::If) => {
self.shift(2);
- try!(self.if_expr(sp));
+ self.if_expr(sp)?;
},
// For
[at!(), keyword!(sp, k), ..] if k.is_keyword(Keyword::For) => {
self.shift(2);
- try!(self.for_expr(sp));
+ self.for_expr(sp)?;
},
// Match
[at!(), keyword!(sp, k), ..] if k.is_keyword(Keyword::Match) => {
self.shift(2);
- try!(self.match_expr(sp));
+ self.match_expr(sp)?;
},
// Call
[at!(), ident!(sp, name), ..] if name.name.as_str() == "call" => {
self.shift(2);
- let func = try!(self.splice(sp));
+ let func = self.splice(sp)?;
self.render.emit_call(func);
},
// Splice
[ref tt @ caret!(), ..] => {
self.shift(1);
- let expr = try!(self.splice(tt.get_span()));
+ let expr = self.splice(tt.get_span())?;
self.render.splice(expr);
},
// Element
[ident!(sp, _), ..] => {
- let name = try!(self.name());
- try!(self.element(sp, &name));
+ let name = self.name()?;
+ self.element(sp, &name)?;
},
// Block
[TokenTree::Delimited(_, ref d), ..] if d.delim == DelimToken::Brace => {
@@ -202,7 +202,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
// result inline
let mut i = &*d.tts;
mem::swap(&mut self.input, &mut i);
- try!(self.markups());
+ self.markups()?;
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.
fn literal(&mut self, tt: &TokenTree, minus: bool) -> PResult<()> {
- let lit = try!(self.with_rust_parser(vec![tt.clone()], RustParser::parse_lit));
- let s = try!(lit_to_string(self.render.cx, lit, minus));
+ let lit = self.with_rust_parser(vec![tt.clone()], RustParser::parse_lit)?;
+ let s = lit_to_string(self.render.cx, lit, minus)?;
self.render.string(&s);
Ok(())
}
@@ -236,7 +236,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
loop { match self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
- if_body = try!(self.block(sp, &d.tts));
+ if_body = self.block(sp, &d.tts)?;
break;
},
[ref tt, ..] => {
@@ -257,7 +257,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
// rather than emitting it right away
let mut r = self.render.fork();
mem::swap(&mut self.render, &mut r);
- try!(self.if_expr(sp));
+ self.if_expr(sp)?;
mem::swap(&mut self.render, &mut r);
r.into_stmts()
};
@@ -265,7 +265,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
},
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
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"),
}
@@ -292,13 +292,13 @@ impl<'cx, 'i> Parser<'cx, 'i> {
},
_ => 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 body;
loop { match self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
- body = try!(self.block(sp, &d.tts));
+ body = self.block(sp, &d.tts)?;
break;
},
[ref tt, ..] => {
@@ -307,7 +307,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
},
_ => 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);
Ok(())
}
@@ -322,12 +322,12 @@ impl<'cx, 'i> Parser<'cx, 'i> {
loop { match self.input {
[TokenTree::Delimited(sp, ref d), ..] if d.delim == DelimToken::Brace => {
self.shift(1);
- match_bodies = try!(Parser {
+ match_bodies = Parser {
in_attr: self.in_attr,
input: &d.tts,
span: sp,
render: self.render.fork(),
- }.match_bodies());
+ }.match_bodies()?;
break;
},
[ref tt, ..] => {
@@ -336,7 +336,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
},
[] => 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);
Ok(())
}
@@ -351,7 +351,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
bodies.push(tt.clone());
},
[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 => {
if expr.is_empty() {
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;
} else {
self.shift(1);
@@ -388,7 +388,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
if expr.is_empty() {
parse_error!(self, sp, "expected body for this @match arm");
} else {
- expr = try!(self.block(sp, &expr)).to_tokens(self.render.cx);
+ expr = self.block(sp, &expr)?.to_tokens(self.render.cx);
break;
}
},
@@ -462,13 +462,13 @@ impl<'cx, 'i> Parser<'cx, 'i> {
parse_error!(self, sp, "unexpected element, you silly bumpkin");
}
self.render.element_open_start(name);
- try!(self.class_shorthand());
- try!(self.attrs());
+ self.class_shorthand()?;
+ self.attrs()?;
self.render.element_open_end();
if let [slash!(), ..] = self.input {
self.shift(1);
} else {
- try!(self.markup());
+ self.markup()?;
self.render.element_close(name);
}
Ok(())
@@ -479,7 +479,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
let mut classes = Vec::new();
while let [dot!(), ident!(_, _), ..] = self.input {
self.shift(1);
- classes.push(try!(self.name()));
+ classes.push(self.name()?);
}
if !classes.is_empty() {
self.render.attribute_start("class");
@@ -503,7 +503,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
// Parse a value under an attribute context
let mut in_attr = true;
mem::swap(&mut self.in_attr, &mut in_attr);
- try!(self.markup());
+ self.markup()?;
mem::swap(&mut self.in_attr, &mut in_attr);
}
self.render.attribute_end();
@@ -514,7 +514,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
if let [ref tt @ eq!(), ..] = self.input {
// Toggle the attribute based on a boolean expression
self.shift(1);
- let cond = try!(self.splice(tt.get_span()));
+ let cond = self.splice(tt.get_span())?;
// Silence "unnecessary parentheses" warnings
let cond = strip_outer_parens(cond).to_tokens(self.render.cx);
let body = {
@@ -561,7 +561,7 @@ impl<'cx, 'i> Parser<'cx, 'i> {
span: sp,
render: self.render.fork(),
};
- try!(parse.markups());
+ parse.markups()?;
Ok(parse.into_render().into_stmts())
}
}