Skip to content

Commit 05ab8f3

Browse files
BurntSushiBurntSushi
committed
*: switch from try! to ?
1 parent 9d9a097 commit 05ab8f3

File tree

14 files changed

+200
-203
lines changed

14 files changed

+200
-203
lines changed

‎regex-debug/src/main.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -123,7 +123,7 @@ fn cmd_ast(args: &Args) -> Result<()> {
123123
use syntax::ast::parse::Parser;
124124

125125
let mut parser = Parser::new();
126-
let ast = try!(parser.parse(&args.arg_pattern));
126+
let ast = parser.parse(&args.arg_pattern)?;
127127
println!("{:#?}", ast);
128128
Ok(())
129129
}
@@ -134,13 +134,13 @@ fn cmd_hir(args: &Args) -> Result<()> {
134134
let mut parser = ParserBuilder::new()
135135
.allow_invalid_utf8(false)
136136
.build();
137-
let hir = try!(parser.parse(&args.arg_pattern));
137+
let hir = parser.parse(&args.arg_pattern)?;
138138
println!("{:#?}", hir);
139139
Ok(())
140140
}
141141

142142
fn cmd_literals(args: &Args) -> Result<()> {
143-
let exprs = try!(args.parse_many());
143+
let exprs = args.parse_many()?;
144144
let mut lits =
145145
if args.cmd_prefixes {
146146
args.literals(&exprs, |lits, e| lits.union_prefixes(e))
@@ -173,7 +173,7 @@ fn cmd_literals(args: &Args) -> Result<()> {
173173
}
174174

175175
fn cmd_anchors(args: &Args) -> Result<()> {
176-
let expr = try!(args.parse_one());
176+
let expr = args.parse_one()?;
177177
if expr.is_anchored_start() {
178178
println!("start");
179179
}
@@ -184,8 +184,8 @@ fn cmd_anchors(args: &Args) -> Result<()> {
184184
}
185185

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

198198
fn cmd_compile(args: &Args) -> Result<()> {
199-
let exprs = try!(args.parse_many());
199+
let exprs = args.parse_many()?;
200200
let compiler =
201201
args.compiler()
202202
.bytes(args.flag_bytes)
203203
.only_utf8(!args.flag_bytes)
204204
.dfa(args.flag_dfa)
205205
.reverse(args.flag_dfa_reverse);
206-
let prog = try!(compiler.compile(&exprs));
206+
let prog = compiler.compile(&exprs)?;
207207
print!("{:?}", prog);
208208
Ok(())
209209
}
@@ -213,9 +213,9 @@ fn cmd_utf8_ranges(args: &Args) -> Result<()> {
213213
use syntax::hir::{self, HirKind};
214214
use utf8_ranges::Utf8Sequences;
215215

216-
let hir = try!(ParserBuilder::new()
216+
let hir = ParserBuilder::new()
217217
.build()
218-
.parse(&format!("[{}]", args.arg_class)));
218+
.parse(&format!("[{}]", args.arg_class))?;
219219
let cls = match hir.into_kind() {
220220
HirKind::Class(hir::Class::Unicode(cls)) => cls,
221221
_ => return Err(

‎regex-syntax/src/ast/parse.rs‎

Lines changed: 37 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -426,9 +426,9 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
426426
/// If the capture limit is exceeded, then an error is returned.
427427
fn next_capture_index(&self, span: Span) -> Result<u32> {
428428
let current = self.parser().capture_index.get();
429-
let i = try!(current.checked_add(1).ok_or_else(|| {
429+
let i = current.checked_add(1).ok_or_else(|| {
430430
self.error(span, ast::ErrorKind::CaptureLimitExceeded)
431-
}));
431+
})?;
432432
self.parser().capture_index.set(i);
433433
Ok(i)
434434
}
@@ -695,7 +695,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
695695
/// is returned.
696696
fn push_group(&self, mut concat: ast::Concat) -> Result<ast::Concat> {
697697
assert_eq!(self.char(), '(');
698-
match try!(self.parse_group()) {
698+
match self.parse_group()? {
699699
Either::Left(set) => {
700700
let ignore = set.flags.flag_state(ast::Flag::IgnoreWhitespace);
701701
if let Some(v) = ignore {
@@ -837,7 +837,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
837837
) -> Result<ast::ClassSetUnion> {
838838
assert_eq!(self.char(), '[');
839839

840-
let (nested_set, nested_union) = try!(self.parse_set_class_open());
840+
let (nested_set, nested_union) = self.parse_set_class_open()?;
841841
self.parser().stack_class.borrow_mut().push(ClassState::Open {
842842
union: parent_union,
843843
set: nested_set,
@@ -987,33 +987,33 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
987987
break;
988988
}
989989
match self.char() {
990-
'(' => concat = try!(self.push_group(concat)),
991-
')' => concat = try!(self.pop_group(concat)),
992-
'|' => concat = try!(self.push_alternate(concat)),
990+
'(' => concat = self.push_group(concat)?,
991+
')' => concat = self.pop_group(concat)?,
992+
'|' => concat = self.push_alternate(concat)?,
993993
'[' => {
994-
let class = try!(self.parse_set_class());
994+
let class = self.parse_set_class()?;
995995
concat.asts.push(Ast::Class(class));
996996
}
997997
'?' => {
998-
concat = try!(self.parse_uncounted_repetition(
999-
concat, ast::RepetitionKind::ZeroOrOne));
998+
concat = self.parse_uncounted_repetition(
999+
concat, ast::RepetitionKind::ZeroOrOne)?;
10001000
}
10011001
'*' => {
1002-
concat = try!(self.parse_uncounted_repetition(
1003-
concat, ast::RepetitionKind::ZeroOrMore));
1002+
concat = self.parse_uncounted_repetition(
1003+
concat, ast::RepetitionKind::ZeroOrMore)?;
10041004
}
10051005
'+' => {
1006-
concat = try!(self.parse_uncounted_repetition(
1007-
concat, ast::RepetitionKind::OneOrMore));
1006+
concat = self.parse_uncounted_repetition(
1007+
concat, ast::RepetitionKind::OneOrMore)?;
10081008
}
10091009
'{' => {
1010-
concat = try!(self.parse_counted_repetition(concat));
1010+
concat = self.parse_counted_repetition(concat)?;
10111011
}
1012-
_ => concat.asts.push(try!(self.parse_primitive()).into_ast()),
1012+
_ => concat.asts.push(self.parse_primitive()?.into_ast()),
10131013
}
10141014
}
1015-
let ast = try!(self.pop_group_end(concat));
1016-
try!(NestLimiter::new(self).check(&ast));
1015+
let ast = self.pop_group_end(concat)?;
1016+
NestLimiter::new(self).check(&ast)?;
10171017
Ok(ast::WithComments {
10181018
ast: ast,
10191019
comments: mem::replace(
@@ -1106,7 +1106,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
11061106
ast::ErrorKind::RepetitionCountUnclosed,
11071107
));
11081108
}
1109-
let count_start = try!(self.parse_decimal());
1109+
let count_start = self.parse_decimal()?;
11101110
let mut range = ast::RepetitionRange::Exactly(count_start);
11111111
if self.is_eof() {
11121112
return Err(self.error(
@@ -1122,7 +1122,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
11221122
));
11231123
}
11241124
if self.char() != '}' {
1125-
let count_end = try!(self.parse_decimal());
1125+
let count_end = self.parse_decimal()?;
11261126
range = ast::RepetitionRange::Bounded(count_start, count_end);
11271127
} else {
11281128
range = ast::RepetitionRange::AtLeast(count_start);
@@ -1191,8 +1191,8 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
11911191
}
11921192
let inner_span = self.span();
11931193
if self.bump_if("?P<") {
1194-
let capture_index = try!(self.next_capture_index(open_span));
1195-
let cap = try!(self.parse_capture_name(capture_index));
1194+
let capture_index = self.next_capture_index(open_span)?;
1195+
let cap = self.parse_capture_name(capture_index)?;
11961196
Ok(Either::Right(ast::Group {
11971197
span: open_span,
11981198
kind: ast::GroupKind::CaptureName(cap),
@@ -1205,7 +1205,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
12051205
ast::ErrorKind::GroupUnclosed,
12061206
));
12071207
}
1208-
let flags = try!(self.parse_flags());
1208+
let flags = self.parse_flags()?;
12091209
let char_end = self.char();
12101210
self.bump();
12111211
if char_end == ')' {
@@ -1230,7 +1230,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
12301230
}))
12311231
}
12321232
} else {
1233-
let capture_index = try!(self.next_capture_index(open_span));
1233+
let capture_index = self.next_capture_index(open_span)?;
12341234
Ok(Either::Right(ast::Group {
12351235
span: open_span,
12361236
kind: ast::GroupKind::CaptureIndex(capture_index),
@@ -1291,7 +1291,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
12911291
name: name.to_string(),
12921292
index: capture_index,
12931293
};
1294-
try!(self.add_capture_name(&capname));
1294+
self.add_capture_name(&capname)?;
12951295
Ok(capname)
12961296
}
12971297

@@ -1334,7 +1334,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
13341334
last_was_negation = None;
13351335
let item = ast::FlagsItem {
13361336
span: self.span_char(),
1337-
kind: ast::FlagsItemKind::Flag(try!(self.parse_flag())),
1337+
kind: ast::FlagsItemKind::Flag(self.parse_flag()?),
13381338
};
13391339
if let Some(i) = flags.add_item(item) {
13401340
return Err(self.error(
@@ -1460,12 +1460,12 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
14601460
));
14611461
}
14621462
'x' | 'u' | 'U' => {
1463-
let mut lit = try!(self.parse_hex());
1463+
let mut lit = self.parse_hex()?;
14641464
lit.span.start = start;
14651465
return Ok(Primitive::Literal(lit));
14661466
}
14671467
'p' | 'P' => {
1468-
let mut cls = try!(self.parse_unicode_class());
1468+
let mut cls = self.parse_unicode_class()?;
14691469
cls.span.start = start;
14701470
return Ok(Primitive::Unicode(cls));
14711471
}
@@ -1756,10 +1756,10 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
17561756
continue;
17571757
}
17581758
}
1759-
union = try!(self.push_class_open(union));
1759+
union = self.push_class_open(union)?;
17601760
}
17611761
']' => {
1762-
match try!(self.pop_class(union)) {
1762+
match self.pop_class(union)? {
17631763
Either::Left(nested_union) => { union = nested_union; }
17641764
Either::Right(class) => return Ok(class),
17651765
}
@@ -1780,7 +1780,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
17801780
ast::ClassSetBinaryOpKind::SymmetricDifference, union);
17811781
}
17821782
_ => {
1783-
union.push(try!(self.parse_set_class_range()));
1783+
union.push(self.parse_set_class_range()?);
17841784
}
17851785
}
17861786
}
@@ -1795,7 +1795,7 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
17951795
/// a simple literal is expected (e.g., in a range), then an error is
17961796
/// returned.
17971797
fn parse_set_class_range(&self) -> Result<ast::ClassSetItem> {
1798-
let prim1 = try!(self.parse_set_class_item());
1798+
let prim1 = self.parse_set_class_item()?;
17991799
self.bump_space();
18001800
if self.is_eof() {
18011801
return Err(self.unclosed_class_error());
@@ -1816,11 +1816,11 @@ impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
18161816
if !self.bump_and_bump_space() {
18171817
return Err(self.unclosed_class_error());
18181818
}
1819-
let prim2 = try!(self.parse_set_class_item());
1819+
let prim2 = self.parse_set_class_item()?;
18201820
let range = ast::ClassSetRange {
18211821
span: Span::new(prim1.span().start, prim2.span().end),
1822-
start: try!(prim1.into_class_literal(self)),
1823-
end: try!(prim2.into_class_literal(self)),
1822+
start: prim1.into_class_literal(self)?,
1823+
end: prim2.into_class_literal(self)?,
18241824
};
18251825
if !range.is_valid() {
18261826
return Err(self.error(
@@ -2121,10 +2121,10 @@ impl<'p, 's, P: Borrow<Parser>> NestLimiter<'p, 's, P> {
21212121
}
21222122

21232123
fn increment_depth(&mut self, span: &Span) -> Result<()> {
2124-
let new = try!(self.depth.checked_add(1).ok_or_else(|| self.p.error(
2124+
let new = self.depth.checked_add(1).ok_or_else(|| self.p.error(
21252125
span.clone(),
21262126
ast::ErrorKind::NestLimitExceeded(::std::u32::MAX),
2127-
)));
2127+
))?;
21282128
let limit = self.p.parser().nest_limit;
21292129
if new > limit {
21302130
return Err(self.p.error(

‎regex-syntax/src/ast/print.rs‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -146,9 +146,9 @@ impl<'p, W: fmt::Write> Visitor for Writer<'p, W> {
146146
Empty(_) => Ok(()),
147147
Literal(ref x) => self.fmt_literal(x),
148148
Range(ref x) => {
149-
try!(self.fmt_literal(&x.start));
150-
try!(self.wtr.write_str("-"));
151-
try!(self.fmt_literal(&x.end));
149+
self.fmt_literal(&x.start)?;
150+
self.wtr.write_str("-")?;
151+
self.fmt_literal(&x.end)?;
152152
Ok(())
153153
}
154154
Ascii(ref x) => self.fmt_class_ascii(x),
@@ -173,15 +173,15 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
173173
match ast.kind {
174174
CaptureIndex(_) => self.wtr.write_str("("),
175175
CaptureName(ref x) => {
176-
try!(self.wtr.write_str("(?P<"));
177-
try!(self.wtr.write_str(&x.name));
178-
try!(self.wtr.write_str(">"));
176+
self.wtr.write_str("(?P<")?;
177+
self.wtr.write_str(&x.name)?;
178+
self.wtr.write_str(">")?;
179179
Ok(())
180180
}
181181
NonCapturing(ref flags) => {
182-
try!(self.wtr.write_str("(?"));
183-
try!(self.fmt_flags(flags));
184-
try!(self.wtr.write_str(":"));
182+
self.wtr.write_str("(?")?;
183+
self.fmt_flags(flags)?;
184+
self.wtr.write_str(":")?;
185185
Ok(())
186186
}
187187
}
@@ -201,9 +201,9 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
201201
OneOrMore if ast.greedy => self.wtr.write_str("+"),
202202
OneOrMore => self.wtr.write_str("+?"),
203203
Range(ref x) => {
204-
try!(self.fmt_repetition_range(x));
204+
self.fmt_repetition_range(x)?;
205205
if !ast.greedy {
206-
try!(self.wtr.write_str("?"));
206+
self.wtr.write_str("?")?;
207207
}
208208
Ok(())
209209
}
@@ -284,17 +284,17 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
284284
}
285285

286286
fn fmt_set_flags(&mut self, ast: &ast::SetFlags) -> fmt::Result {
287-
try!(self.wtr.write_str("(?"));
288-
try!(self.fmt_flags(&ast.flags));
289-
try!(self.wtr.write_str(")"));
287+
self.wtr.write_str("(?")?;
288+
self.fmt_flags(&ast.flags)?;
289+
self.wtr.write_str(")")?;
290290
Ok(())
291291
}
292292

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

296296
for item in &ast.items {
297-
try!(match item.kind {
297+
match item.kind {
298298
FlagsItemKind::Negation => self.wtr.write_str("-"),
299299
FlagsItemKind::Flag(ref flag) => {
300300
match *flag {
@@ -306,7 +306,7 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
306306
Flag::IgnoreWhitespace => self.wtr.write_str("x"),
307307
}
308308
}
309-
});
309+
}?;
310310
}
311311
Ok(())
312312
}
@@ -392,9 +392,9 @@ impl<'p, W: fmt::Write> Writer<'p, W> {
392392
use ast::ClassUnicodeOpKind::*;
393393

394394
if ast.negated {
395-
try!(self.wtr.write_str(r"\P"));
395+
self.wtr.write_str(r"\P")?;
396396
} else {
397-
try!(self.wtr.write_str(r"\p"));
397+
self.wtr.write_str(r"\p")?;
398398
}
399399
match ast.kind {
400400
OneLetter(c) => self.wtr.write_char(c),

0 commit comments

Comments
 (0)