Skip to content

Commit

Permalink
*: switch from try! to ?
Browse files Browse the repository at this point in the history
  • Loading branch information
@BurntSushi
BurntSushi committed May 1, 2018
1 parent 9d9a097 commit 05ab8f3
Show file tree
Hide file tree
Showing 14 changed files with 200 additions and 203 deletions.
20 changes: 10 additions & 10 deletions regex-debug/src/main.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -123,7 +123,7 @@ fn cmd_ast(args: &Args) -> Result<()> {
use syntax::ast::parse::Parser;

let mut parser = Parser::new();
let ast = try!(parser.parse(&args.arg_pattern));
let ast = parser.parse(&args.arg_pattern)?;
println!("{:#?}", ast);
Ok(())
}
Expand All @@ -134,13 +134,13 @@ fn cmd_hir(args: &Args) -> Result<()> {
let mut parser = ParserBuilder::new()
.allow_invalid_utf8(false)
.build();
let hir = try!(parser.parse(&args.arg_pattern));
let hir = parser.parse(&args.arg_pattern)?;
println!("{:#?}", hir);
Ok(())
}

fn cmd_literals(args: &Args) -> Result<()> {
let exprs = try!(args.parse_many());
let exprs = args.parse_many()?;
let mut lits =
if args.cmd_prefixes {
args.literals(&exprs, |lits, e| lits.union_prefixes(e))
Expand Down Expand Up @@ -173,7 +173,7 @@ fn cmd_literals(args: &Args) -> Result<()> {
}

fn cmd_anchors(args: &Args) -> Result<()> {
let expr = try!(args.parse_one());
let expr = args.parse_one()?;
if expr.is_anchored_start() {
println!("start");
}
Expand All @@ -184,8 +184,8 @@ fn cmd_anchors(args: &Args) -> Result<()> {
}

fn cmd_captures(args: &Args) -> Result<()> {
let expr = try!(args.parse_one());
let prog = try!(args.compiler().only_utf8(false).compile(&[expr]));
let expr = args.parse_one()?;
let prog = args.compiler().only_utf8(false).compile(&[expr])?;
for (i, name) in prog.captures.iter().enumerate() {
match *name {
None => println!("{}", i),
Expand All @@ -196,14 +196,14 @@ fn cmd_captures(args: &Args) -> Result<()> {
}

fn cmd_compile(args: &Args) -> Result<()> {
let exprs = try!(args.parse_many());
let exprs = args.parse_many()?;
let compiler =
args.compiler()
.bytes(args.flag_bytes)
.only_utf8(!args.flag_bytes)
.dfa(args.flag_dfa)
.reverse(args.flag_dfa_reverse);
let prog = try!(compiler.compile(&exprs));
let prog = compiler.compile(&exprs)?;
print!("{:?}", prog);
Ok(())
}
Expand All @@ -213,9 +213,9 @@ fn cmd_utf8_ranges(args: &Args) -> Result<()> {
use syntax::hir::{self, HirKind};
use utf8_ranges::Utf8Sequences;

let hir = try!(ParserBuilder::new()
let hir = ParserBuilder::new()
.build()
.parse(&format!("[{}]", args.arg_class)));
.parse(&format!("[{}]", args.arg_class))?;
let cls = match hir.into_kind() {
HirKind::Class(hir::Class::Unicode(cls)) => cls,
_ => return Err(
Expand Down
74 changes: 37 additions & 37 deletions regex-syntax/src/ast/parse.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -426,9 +426,9 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
/// If the capture limit is exceeded, then an error is returned.
fn next_capture_index(&self, span: Span) -> Result<u32> {
let current = self.parser().capture_index.get();
let i = try!(current.checked_add(1).ok_or_else(|| {
let i = current.checked_add(1).ok_or_else(|| {
self.error(span, ast::ErrorKind::CaptureLimitExceeded)
}));
})?;
self.parser().capture_index.set(i);
Ok(i)
}
Expand Down Expand Up @@ -695,7 +695,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
/// is returned.
fn push_group(&self, mut concat: ast::Concat) -> Result<ast::Concat> {
assert_eq!(self.char(), '(');
match try!(self.parse_group()) {
match self.parse_group()? {
Either::Left(set) => {
let ignore = set.flags.flag_state(ast::Flag::IgnoreWhitespace);
if let Some(v) = ignore {
Expand Down Expand Up @@ -837,7 +837,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
) -> Result<ast::ClassSetUnion> {
assert_eq!(self.char(), '[');

let (nested_set, nested_union) = try!(self.parse_set_class_open());
let (nested_set, nested_union) = self.parse_set_class_open()?;
self.parser().stack_class.borrow_mut().push(ClassState::Open {
union: parent_union,
set: nested_set,
Expand Down Expand Up @@ -987,33 +987,33 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
break;
}
match self.char() {
'(' => concat = try!(self.push_group(concat)),
')' => concat = try!(self.pop_group(concat)),
'|' => concat = try!(self.push_alternate(concat)),
'(' => concat = self.push_group(concat)?,
')' => concat = self.pop_group(concat)?,
'|' => concat = self.push_alternate(concat)?,
'[' => {
let class = try!(self.parse_set_class());
let class = self.parse_set_class()?;
concat.asts.push(Ast::Class(class));
}
'?' => {
concat = try!(self.parse_uncounted_repetition(
concat, ast::RepetitionKind::ZeroOrOne));
concat = self.parse_uncounted_repetition(
concat, ast::RepetitionKind::ZeroOrOne)?;
}
'*' => {
concat = try!(self.parse_uncounted_repetition(
concat, ast::RepetitionKind::ZeroOrMore));
concat = self.parse_uncounted_repetition(
concat, ast::RepetitionKind::ZeroOrMore)?;
}
'+' => {
concat = try!(self.parse_uncounted_repetition(
concat, ast::RepetitionKind::OneOrMore));
concat = self.parse_uncounted_repetition(
concat, ast::RepetitionKind::OneOrMore)?;
}
'{' => {
concat = try!(self.parse_counted_repetition(concat));
concat = self.parse_counted_repetition(concat)?;
}
_ => concat.asts.push(try!(self.parse_primitive()).into_ast()),
_ => concat.asts.push(self.parse_primitive()?.into_ast()),
}
}
let ast = try!(self.pop_group_end(concat));
try!(NestLimiter::new(self).check(&ast));
let ast = self.pop_group_end(concat)?;
NestLimiter::new(self).check(&ast)?;
Ok(ast::WithComments {
ast: ast,
comments: mem::replace(
Expand Down Expand Up @@ -1106,7 +1106,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
ast::ErrorKind::RepetitionCountUnclosed,
));
}
let count_start = try!(self.parse_decimal());
let count_start = self.parse_decimal()?;
let mut range = ast::RepetitionRange::Exactly(count_start);
if self.is_eof() {
return Err(self.error(
Expand All @@ -1122,7 +1122,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
));
}
if self.char() != '}' {
let count_end = try!(self.parse_decimal());
let count_end = self.parse_decimal()?;
range = ast::RepetitionRange::Bounded(count_start, count_end);
} else {
range = ast::RepetitionRange::AtLeast(count_start);
Expand Down Expand Up @@ -1191,8 +1191,8 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
}
let inner_span = self.span();
if self.bump_if("?P<") {
let capture_index = try!(self.next_capture_index(open_span));
let cap = try!(self.parse_capture_name(capture_index));
let capture_index = self.next_capture_index(open_span)?;
let cap = self.parse_capture_name(capture_index)?;
Ok(Either::Right(ast::Group {
span: open_span,
kind: ast::GroupKind::CaptureName(cap),
Expand All @@ -1205,7 +1205,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
ast::ErrorKind::GroupUnclosed,
));
}
let flags = try!(self.parse_flags());
let flags = self.parse_flags()?;
let char_end = self.char();
self.bump();
if char_end == ')' {
Expand All @@ -1230,7 +1230,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
}))
}
} else {
let capture_index = try!(self.next_capture_index(open_span));
let capture_index = self.next_capture_index(open_span)?;
Ok(Either::Right(ast::Group {
span: open_span,
kind: ast::GroupKind::CaptureIndex(capture_index),
Expand Down Expand Up @@ -1291,7 +1291,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
name: name.to_string(),
index: capture_index,
};
try!(self.add_capture_name(&capname));
self.add_capture_name(&capname)?;
Ok(capname)
}

Expand Down Expand Up @@ -1334,7 +1334,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
last_was_negation = None;
let item = ast::FlagsItem {
span: self.span_char(),
kind: ast::FlagsItemKind::Flag(try!(self.parse_flag())),
kind: ast::FlagsItemKind::Flag(self.parse_flag()?),
};
if let Some(i) = flags.add_item(item) {
return Err(self.error(
Expand Down Expand Up @@ -1460,12 +1460,12 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
));
}
'x' | 'u' | 'U' => {
let mut lit = try!(self.parse_hex());
let mut lit = self.parse_hex()?;
lit.span.start = start;
return Ok(Primitive::Literal(lit));
}
'p' | 'P' => {
let mut cls = try!(self.parse_unicode_class());
let mut cls = self.parse_unicode_class()?;
cls.span.start = start;
return Ok(Primitive::Unicode(cls));
}
Expand Down Expand Up @@ -1756,10 +1756,10 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
continue;
}
}
union = try!(self.push_class_open(union));
union = self.push_class_open(union)?;
}
']' => {
match try!(self.pop_class(union)) {
match self.pop_class(union)? {
Either::Left(nested_union) => { union = nested_union; }
Either::Right(class) => return Ok(class),
}
Expand All @@ -1780,7 +1780,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
ast::ClassSetBinaryOpKind::SymmetricDifference, union);
}
_ => {
union.push(try!(self.parse_set_class_range()));
union.push(self.parse_set_class_range()?);
}
}
}
Expand All @@ -1795,7 +1795,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
/// a simple literal is expected (e.g., in a range), then an error is
/// returned.
fn parse_set_class_range(&self) -> Result<ast::ClassSetItem> {
let prim1 = try!(self.parse_set_class_item());
let prim1 = self.parse_set_class_item()?;
self.bump_space();
if self.is_eof() {
return Err(self.unclosed_class_error());
Expand All @@ -1816,11 +1816,11 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
if !self.bump_and_bump_space() {
return Err(self.unclosed_class_error());
}
let prim2 = try!(self.parse_set_class_item());
let prim2 = self.parse_set_class_item()?;
let range = ast::ClassSetRange {
span: Span::new(prim1.span().start, prim2.span().end),
start: try!(prim1.into_class_literal(self)),
end: try!(prim2.into_class_literal(self)),
start: prim1.into_class_literal(self)?,
end: prim2.into_class_literal(self)?,
};
if !range.is_valid() {
return Err(self.error(
Expand Down Expand Up @@ -2121,10 +2121,10 @@ impl<'p, 's, P: Borrow<Parser>> NestLimiter<'p, 's, P> {
}

fn increment_depth(&mut self, span: &Span) -> Result<()> {
let new = try!(self.depth.checked_add(1).ok_or_else(|| self.p.error(
let new = self.depth.checked_add(1).ok_or_else(|| self.p.error(
span.clone(),
ast::ErrorKind::NestLimitExceeded(::std::u32::MAX),
)));
))?;
let limit = self.p.parser().nest_limit;
if new > limit {
return Err(self.p.error(
Expand Down
36 changes: 18 additions & 18 deletions regex-syntax/src/ast/print.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -146,9 +146,9 @@ impl<'p, W: fmt::Write> Visitor for Writer<'p, W> {
Empty(_) => Ok(()),
Literal(ref x) => self.fmt_literal(x),
Range(ref x) => {
try!(self.fmt_literal(&x.start));
try!(self.wtr.write_str("-"));
try!(self.fmt_literal(&x.end));
self.fmt_literal(&x.start)?;
self.wtr.write_str("-")?;
self.fmt_literal(&x.end)?;
Ok(())
}
Ascii(ref x) => self.fmt_class_ascii(x),
Expand All @@ -173,15 +173,15 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
match ast.kind {
CaptureIndex(_) => self.wtr.write_str("("),
CaptureName(ref x) => {
try!(self.wtr.write_str("(?P<"));
try!(self.wtr.write_str(&x.name));
try!(self.wtr.write_str(">"));
self.wtr.write_str("(?P<")?;
self.wtr.write_str(&x.name)?;
self.wtr.write_str(">")?;
Ok(())
}
NonCapturing(ref flags) => {
try!(self.wtr.write_str("(?"));
try!(self.fmt_flags(flags));
try!(self.wtr.write_str(":"));
self.wtr.write_str("(?")?;
self.fmt_flags(flags)?;
self.wtr.write_str(":")?;
Ok(())
}
}
Expand All @@ -201,9 +201,9 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
OneOrMore if ast.greedy => self.wtr.write_str("+"),
OneOrMore => self.wtr.write_str("+?"),
Range(ref x) => {
try!(self.fmt_repetition_range(x));
self.fmt_repetition_range(x)?;
if !ast.greedy {
try!(self.wtr.write_str("?"));
self.wtr.write_str("?")?;
}
Ok(())
}
Expand Down Expand Up @@ -284,17 +284,17 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
}

fn fmt_set_flags(&mut self, ast: &ast::SetFlags) -> fmt::Result {
try!(self.wtr.write_str("(?"));
try!(self.fmt_flags(&ast.flags));
try!(self.wtr.write_str(")"));
self.wtr.write_str("(?")?;
self.fmt_flags(&ast.flags)?;
self.wtr.write_str(")")?;
Ok(())
}

fn fmt_flags(&mut self, ast: &ast::Flags) -> fmt::Result {
use ast::{Flag, FlagsItemKind};

for item in &ast.items {
try!(match item.kind {
match item.kind {
FlagsItemKind::Negation => self.wtr.write_str("-"),
FlagsItemKind::Flag(ref flag) => {
match *flag {
Expand All @@ -306,7 +306,7 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
Flag::IgnoreWhitespace => self.wtr.write_str("x"),
}
}
});
}?;
}
Ok(())
}
Expand Down Expand Up @@ -392,9 +392,9 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
use ast::ClassUnicodeOpKind::*;

if ast.negated {
try!(self.wtr.write_str(r"\P"));
self.wtr.write_str(r"\P")?;
} else {
try!(self.wtr.write_str(r"\p"));
self.wtr.write_str(r"\p")?;
}
match ast.kind {
OneLetter(c) => self.wtr.write_char(c),
Expand Down

0 comments on commit 05ab8f3

Please sign in to comment.