diff options
| author | Jorge Aparicio <japaricious@gmail.com> | 2016-03-22 22:01:37 -0500 |
|---|---|---|
| committer | Jorge Aparicio <japaricious@gmail.com> | 2016-03-22 22:01:37 -0500 |
| commit | 0f02309e4b0ea05ee905205278fb6d131341c41f (patch) | |
| tree | a259129eeb84705de15b51587ddebd0f82735075 /src/libsyntax/parse | |
| parent | 0dcc413e42f15f4fc51a0ca88a99cc89454ec43d (diff) | |
| download | rust-0f02309e4b0ea05ee905205278fb6d131341c41f.tar.gz rust-0f02309e4b0ea05ee905205278fb6d131341c41f.zip | |
try! -> ?
Automated conversion using the untry tool [1] and the following command: ``` $ find -name '*.rs' -type f | xargs untry ``` at the root of the Rust repo. [1]: https://github.com/japaric/untry
Diffstat (limited to 'src/libsyntax/parse')
| -rw-r--r-- | src/libsyntax/parse/attr.rs | 16 | ||||
| -rw-r--r-- | src/libsyntax/parse/parser.rs | 978 | ||||
| -rw-r--r-- | src/libsyntax/parse/token.rs | 2 |
3 files changed, 498 insertions, 498 deletions
diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 0950d6082e7..b8e320e36e9 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -25,7 +25,7 @@ impl<'a> Parser<'a> { debug!("parse_outer_attributes: self.token={:?}", self.token); match self.token { token::Pound => { - attrs.push(try!(self.parse_attribute(false))); + attrs.push(self.parse_attribute(false)?); } token::DocComment(s) => { let attr = ::attr::mk_sugared_doc_attr( @@ -79,10 +79,10 @@ impl<'a> Parser<'a> { ast::AttrStyle::Outer }; - try!(self.expect(&token::OpenDelim(token::Bracket))); - let meta_item = try!(self.parse_meta_item()); + self.expect(&token::OpenDelim(token::Bracket))?; + let meta_item = self.parse_meta_item()?; let hi = self.span.hi; - try!(self.expect(&token::CloseDelim(token::Bracket))); + self.expect(&token::CloseDelim(token::Bracket))?; (mk_sp(lo, hi), meta_item, style) } @@ -126,7 +126,7 @@ impl<'a> Parser<'a> { break; } - let attr = try!(self.parse_attribute(true)); + let attr = self.parse_attribute(true)?; assert!(attr.node.style == ast::AttrStyle::Inner); attrs.push(attr); } @@ -166,12 +166,12 @@ impl<'a> Parser<'a> { } let lo = self.span.lo; - let ident = try!(self.parse_ident()); + let ident = self.parse_ident()?; let name = self.id_to_interned_str(ident); match self.token { token::Eq => { self.bump(); - let lit = try!(self.parse_lit()); + let lit = self.parse_lit()?; // FIXME #623 Non-string meta items are not serialized correctly; // just forbid them for now match lit.node { @@ -185,7 +185,7 @@ impl<'a> Parser<'a> { Ok(P(spanned(lo, hi, ast::MetaItemKind::NameValue(name, lit)))) } token::OpenDelim(token::Paren) => { - let inner_items = try!(self.parse_meta_seq()); + let inner_items = self.parse_meta_seq()?; let hi = self.span.hi; Ok(P(spanned(lo, hi, ast::MetaItemKind::List(name, inner_items)))) } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 6839f11cd70..827f3331753 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -590,11 +590,11 @@ impl<'a> Parser<'a> { pub fn parse_path_list_item(&mut self) -> PResult<'a, ast::PathListItem> { let lo = self.span.lo; let node = if self.eat_keyword(keywords::SelfValue) { - let rename = try!(self.parse_rename()); + let rename = self.parse_rename()?; ast::PathListItemKind::Mod { id: ast::DUMMY_NODE_ID, rename: rename } } else { - let ident = try!(self.parse_ident()); - let rename = try!(self.parse_rename()); + let ident = self.parse_ident()?; + let rename = self.parse_rename()?; ast::PathListItemKind::Ident { name: ident, rename: rename, id: ast::DUMMY_NODE_ID } }; let hi = self.last_span.hi; @@ -811,13 +811,13 @@ impl<'a> Parser<'a> { } if i % 2 == 0 { - match try!(f(self)) { + match f(self)? { Some(result) => v.push(result), None => return Ok((P::from_vec(v), true)) } } else { if let Some(t) = sep.as_ref() { - try!(self.expect(t)); + self.expect(t)?; } } @@ -833,8 +833,8 @@ impl<'a> Parser<'a> { -> PResult<'a, P<[T]>> where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>, { - let (result, returned) = try!(self.parse_seq_to_before_gt_or_return(sep, - |p| Ok(Some(try!(f(p)))))); + let (result, returned) = self.parse_seq_to_before_gt_or_return(sep, + |p| Ok(Some(f(p)?)))?; assert!(!returned); return Ok(result); } @@ -845,8 +845,8 @@ impl<'a> Parser<'a> { -> PResult<'a, P<[T]>> where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>, { - let v = try!(self.parse_seq_to_before_gt(sep, f)); - try!(self.expect_gt()); + let v = self.parse_seq_to_before_gt(sep, f)?; + self.expect_gt()?; return Ok(v); } @@ -856,9 +856,9 @@ impl<'a> Parser<'a> { -> PResult<'a, (P<[T]>, bool)> where F: FnMut(&mut Parser<'a>) -> PResult<'a, Option<T>>, { - let (v, returned) = try!(self.parse_seq_to_before_gt_or_return(sep, f)); + let (v, returned) = self.parse_seq_to_before_gt_or_return(sep, f)?; if !returned { - try!(self.expect_gt()); + self.expect_gt()?; } return Ok((v, returned)); } @@ -953,7 +953,7 @@ impl<'a> Parser<'a> { -> PResult<'a, Vec<T>> where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>, { - try!(self.expect(bra)); + self.expect(bra)?; let result = self.parse_seq_to_before_end(ket, sep, f); self.bump(); Ok(result) @@ -969,7 +969,7 @@ impl<'a> Parser<'a> { -> PResult<'a, Vec<T>> where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>, { - let result = try!(self.parse_unspanned_seq(bra, ket, sep, f)); + let result = self.parse_unspanned_seq(bra, ket, sep, f)?; if result.is_empty() { let last_span = self.last_span; self.span_err(last_span, @@ -989,7 +989,7 @@ impl<'a> Parser<'a> { F: FnMut(&mut Parser<'a>) -> PResult<'a, T>, { let lo = self.span.lo; - try!(self.expect(bra)); + self.expect(bra)?; let result = self.parse_seq_to_before_end(ket, sep, f); let hi = self.span.hi; self.bump(); @@ -1142,19 +1142,19 @@ impl<'a> Parser<'a> { // parse <'lt> let lo = self.span.lo; - let lifetime_defs = try!(self.parse_late_bound_lifetime_defs()); + let lifetime_defs = self.parse_late_bound_lifetime_defs()?; // examine next token to decide to do if self.token_is_bare_fn_keyword() { self.parse_ty_bare_fn(lifetime_defs) } else { let hi = self.span.hi; - let trait_ref = try!(self.parse_trait_ref()); + let trait_ref = self.parse_trait_ref()?; let poly_trait_ref = ast::PolyTraitRef { bound_lifetimes: lifetime_defs, trait_ref: trait_ref, span: mk_sp(lo, hi)}; let other_bounds = if self.eat(&token::BinOp(token::Plus)) { - try!(self.parse_ty_param_bounds(BoundParsingMode::Bare)) + self.parse_ty_param_bounds(BoundParsingMode::Bare)? } else { P::empty() }; @@ -1167,7 +1167,7 @@ impl<'a> Parser<'a> { } pub fn parse_ty_path(&mut self) -> PResult<'a, TyKind> { - Ok(TyKind::Path(None, try!(self.parse_path(LifetimeAndTypesWithoutColons)))) + Ok(TyKind::Path(None, self.parse_path(LifetimeAndTypesWithoutColons)?)) } /// parse a TyKind::BareFn type: @@ -1185,16 +1185,16 @@ impl<'a> Parser<'a> { Function Style */ - let unsafety = try!(self.parse_unsafety()); + let unsafety = self.parse_unsafety()?; let abi = if self.eat_keyword(keywords::Extern) { - try!(self.parse_opt_abi()).unwrap_or(Abi::C) + self.parse_opt_abi()?.unwrap_or(Abi::C) } else { Abi::Rust }; - try!(self.expect_keyword(keywords::Fn)); - let (inputs, variadic) = try!(self.parse_fn_args(false, true)); - let ret_ty = try!(self.parse_ret_ty()); + self.expect_keyword(keywords::Fn)?; + let (inputs, variadic) = self.parse_fn_args(false, true)?; + let ret_ty = self.parse_ret_ty()?; let decl = P(FnDecl { inputs: inputs, output: ret_ty, @@ -1254,25 +1254,25 @@ impl<'a> Parser<'a> { SeqSep::none(), |p| -> PResult<'a, TraitItem> { maybe_whole!(no_clone_from_p p, NtTraitItem); - let mut attrs = try!(p.parse_outer_attributes()); + let mut attrs = p.parse_outer_attributes()?; let lo = p.span.lo; let (name, node) = if p.eat_keyword(keywords::Type) { - let TyParam {ident, bounds, default, ..} = try!(p.parse_ty_param()); - try!(p.expect(&token::Semi)); + let TyParam {ident, bounds, default, ..} = p.parse_ty_param()?; + p.expect(&token::Semi)?; (ident, TraitItemKind::Type(bounds, default)) } else if p.is_const_item() { - try!(p.expect_keyword(keywords::Const)); - let ident = try!(p.parse_ident()); - try!(p.expect(&token::Colon)); - let ty = try!(p.parse_ty_sum()); + p.expect_keyword(keywords::Const)?; + let ident = p.parse_ident()?; + p.expect(&token::Colon)?; + let ty = p.parse_ty_sum()?; let default = if p.check(&token::Eq) { p.bump(); - let expr = try!(p.parse_expr()); - try!(p.commit_expr_expecting(&expr, token::Semi)); + let expr = p.parse_expr()?; + p.commit_expr_expecting(&expr, token::Semi)?; Some(expr) } else { - try!(p.expect(&token::Semi)); + p.expect(&token::Semi)?; None }; (ident, TraitItemKind::Const(ty, default)) @@ -1288,7 +1288,7 @@ impl<'a> Parser<'a> { } if p.token == token::OpenDelim(token::DelimToken::Brace) { - try!(p.parse_token_tree()); + p.parse_token_tree()?; break; } } @@ -1297,17 +1297,17 @@ impl<'a> Parser<'a> { } }; - let ident = try!(p.parse_ident()); - let mut generics = try!(p.parse_generics()); + let ident = p.parse_ident()?; + let mut generics = p.parse_generics()?; - let (explicit_self, d) = try!(p.parse_fn_decl_with_self(|p: &mut Parser<'a>|{ + let (explicit_self, d) = p.parse_fn_decl_with_self(|p: &mut Parser<'a>|{ // This is somewhat dubious; We don't want to allow // argument names to be left off if there is a // definition... p.parse_arg_general(false) - })); + })?; - generics.where_clause = try!(p.parse_where_clause()); + generics.where_clause = p.parse_where_clause()?; let sig = ast::MethodSig { unsafety: unsafety, constness: constness, @@ -1326,7 +1326,7 @@ impl<'a> Parser<'a> { token::OpenDelim(token::Brace) => { debug!("parse_trait_methods(): parsing provided method"); let (inner_attrs, body) = - try!(p.parse_inner_attrs_and_block()); + p.parse_inner_attrs_and_block()?; attrs.extend(inner_attrs.iter().cloned()); Some(body) } @@ -1352,8 +1352,8 @@ impl<'a> Parser<'a> { /// Parse a possibly mutable type pub fn parse_mt(&mut self) -> PResult<'a, MutTy> { - let mutbl = try!(self.parse_mutability()); - let t = try!(self.parse_ty()); + let mutbl = self.parse_mutability()?; + let t = self.parse_ty()?; Ok(MutTy { ty: t, mutbl: mutbl }) } @@ -1363,7 +1363,7 @@ impl<'a> Parser<'a> { if self.eat(&token::Not) { Ok(FunctionRetTy::None(self.last_span)) } else { - Ok(FunctionRetTy::Ty(try!(self.parse_ty()))) + Ok(FunctionRetTy::Ty(self.parse_ty()?)) } } else { let pos = self.span.lo; @@ -1374,13 +1374,13 @@ impl<'a> Parser<'a> { /// Parse a type in a context where `T1+T2` is allowed. pub fn parse_ty_sum(&mut self) -> PResult<'a, P<Ty>> { let lo = self.span.lo; - let lhs = try!(self.parse_ty()); + let lhs = self.parse_ty()?; if !self.eat(&token::BinOp(token::Plus)) { return Ok(lhs); } - let bounds = try!(self.parse_ty_param_bounds(BoundParsingMode::Bare)); + let bounds = self.parse_ty_param_bounds(BoundParsingMode::Bare)?; // In type grammar, `+` is treated like a binary operator, // and hence both L and R side are required. @@ -1411,7 +1411,7 @@ impl<'a> Parser<'a> { let mut ts = vec![]; let mut last_comma = false; while self.token != token::CloseDelim(token::Paren) { - ts.push(try!(self.parse_ty_sum())); + ts.push(self.parse_ty_sum()?); if self.check(&token::Comma) { last_comma = true; self.bump(); @@ -1421,7 +1421,7 @@ impl<'a> Parser<'a> { } } - try!(self.expect(&token::CloseDelim(token::Paren))); + self.expect(&token::CloseDelim(token::Paren))?; if ts.len() == 1 && !last_comma { TyKind::Paren(ts.into_iter().nth(0).unwrap()) } else { @@ -1430,54 +1430,54 @@ impl<'a> Parser<'a> { } else if self.check(&token::BinOp(token::Star)) { // STAR POINTER (bare pointer?) self.bump(); - TyKind::Ptr(try!(self.parse_ptr())) + TyKind::Ptr(self.parse_ptr()?) } else if self.check(&token::OpenDelim(token::Bracket)) { // VECTOR - try!(self.expect(&token::OpenDelim(token::Bracket))); - let t = try!(self.parse_ty_sum()); + self.expect(&token::OpenDelim(token::Bracket))?; + let t = self.parse_ty_sum()?; // Parse the `; e` in `[ i32; e ]` // where `e` is a const expression - let t = match try!(self.maybe_parse_fixed_length_of_vec()) { + let t = match self.maybe_parse_fixed_length_of_vec()? { None => TyKind::Vec(t), Some(suffix) => TyKind::FixedLengthVec(t, suffix) }; - try!(self.expect(&token::CloseDelim(token::Bracket))); + self.expect(&token::CloseDelim(token::Bracket))?; t } else if self.check(&token::BinOp(token::And)) || self.token == token::AndAnd { // BORROWED POINTER - try!(self.expect_and()); - try!(self.parse_borrowed_pointee()) + self.expect_and()?; + self.parse_borrowed_pointee()? } else if self.check_keyword(keywords::For) { - try!(self.parse_for_in_type()) + self.parse_for_in_type()? } else if self.token_is_bare_fn_keyword() { // BARE FUNCTION - try!(self.parse_ty_bare_fn(Vec::new())) + self.parse_ty_bare_fn(Vec::new())? } else if self.eat_keyword_noexpect(keywords::Typeof) { // TYPEOF // In order to not be ambiguous, the type must be surrounded by parens. - try!(self.expect(&token::OpenDelim(token::Paren))); - let e = try!(self.parse_expr()); - try!(self.expect(&token::CloseDelim(token::Paren))); + self.expect(&token::OpenDelim(token::Paren))?; + let e = self.parse_expr()?; + self.expect(&token::CloseDelim(token::Paren))?; TyKind::Typeof(e) } else if self.eat_lt() { let (qself, path) = - try!(self.parse_qualified_path(NoTypesAllowed)); + self.parse_qualified_path(NoTypesAllowed)?; TyKind::Path(Some(qself), path) } else if self.check(&token::ModSep) || self.token.is_ident() || self.token.is_path() { - let path = try!(self.parse_path(LifetimeAndTypesWithoutColons)); + let path = self.parse_path(LifetimeAndTypesWithoutColons)?; if self.check(&token::Not) { // MACRO INVOCATION self.bump(); - let delim = try!(self.expect_open_delim()); - let tts = try!(self.parse_seq_to_end(&token::CloseDelim(delim), + let delim = self.expect_open_delim()?; + let tts = self.parse_seq_to_end(&token::CloseDelim(delim), SeqSep::none(), - |p| p.parse_token_tree())); + |p| p.parse_token_tree())?; let hi = self.span.hi; TyKind::Mac(spanned(lo, hi, Mac_ { path: path, tts: tts, ctxt: EMPTY_CTXT })) } else { @@ -1499,9 +1499,9 @@ impl<'a> Parser<'a> { pub fn parse_borrowed_pointee(&mut self) -> PResult<'a, TyKind> { // look for `&'lt` or `&'foo ` and interpret `foo` as the region name: - let opt_lifetime = try!(self.parse_opt_lifetime()); + let opt_lifetime = self.parse_opt_lifetime()?; - let mt = try!(self.parse_mt()); + let mt = self.parse_mt()?; return Ok(TyKind::Rptr(opt_lifetime, mt)); } @@ -1518,7 +1518,7 @@ impl<'a> Parser<'a> { known as `*const T`"); Mutability::Immutable }; - let t = try!(self.parse_ty()); + let t = self.parse_ty()?; Ok(MutTy { ty: t, mutbl: mutbl }) } @@ -1549,9 +1549,9 @@ impl<'a> Parser<'a> { let pat = if require_name || self.is_named_argument() { debug!("parse_arg_general parse_pat (require_name:{})", require_name); - let pat = try!(self.parse_pat()); + let pat = self.parse_pat()?; - try!(self.expect(&token::Colon)); + self.expect(&token::Colon)?; pat } else { debug!("parse_arg_general ident_to_pat"); @@ -1560,7 +1560,7 @@ impl<'a> Parser<'a> { special_idents::invalid) }; - let t = try!(self.parse_ty_sum()); + let t = self.parse_ty_sum()?; Ok(Arg { ty: t, @@ -1576,9 +1576,9 @@ impl<'a> Parser<'a> { /// Parse an argument in a lambda header e.g. |arg, arg| pub fn parse_fn_block_arg(&mut self) -> PResult<'a, Arg> { - let pat = try!(self.parse_pat()); + let pat = self.parse_pat()?; let t = if self.eat(&token::Colon) { - try!(self.parse_ty_sum()) + self.parse_ty_sum()? } else { P(Ty { id: ast::DUMMY_NODE_ID, @@ -1596,7 +1596,7 @@ impl<'a> Parser<'a> { pub fn maybe_parse_fixed_length_of_vec(&mut self) -> PResult<'a, Option<P<ast::Expr>>> { if self.check(&token::Semi) { self.bump(); - Ok(Some(try!(self.parse_expr()))) + Ok(Some(self.parse_expr()?)) } else { Ok(None) } @@ -1670,7 +1670,7 @@ impl<'a> Parser<'a> { LitKind::Bool(false) } else { let token = self.bump_and_get(); - let lit = try!(self.lit_from_token(&token)); + let lit = self.lit_from_token(&token)?; lit }; Ok(codemap::Spanned { node: lit, span: mk_sp(lo, self.last_span.hi) }) @@ -1681,7 +1681,7 @@ impl<'a> Parser<'a> { let minus_lo = self.span.lo; let minus_present = self.eat(&token::BinOp(token::Minus)); let lo = self.span.lo; - let literal = P(try!(self.parse_lit())); + let literal = P(self.parse_lit()?); let hi = self.last_span.hi; let expr = self.mk_expr(lo, hi, ExprKind::Lit(literal), None); @@ -1712,9 +1712,9 @@ impl<'a> Parser<'a> { pub fn parse_qualified_path(&mut self, mode: PathParsingMode) -> PResult<'a, (QSelf, ast::Path)> { let span = self.last_span; - let self_type = try!(self.parse_ty_sum()); + let self_type = self.parse_ty_sum()?; let mut path = if self.eat_keyword(keywords::As) { - try!(self.parse_path(LifetimeAndTypesWithoutColons)) + self.parse_path(LifetimeAndTypesWithoutColons)? } else { ast::Path { span: span, @@ -1728,18 +1728,18 @@ impl<'a> Parser<'a> { position: path.segments.len() }; - try!(self.expect(&token::Gt)); - try!(self.expect(&token::ModSep)); + self.expect(&token::Gt)?; + self.expect(&token::ModSep)?; let segments = match mode { LifetimeAndTypesWithoutColons => { - try!(self.parse_path_segments_without_colons()) + self.parse_path_segments_without_colons()? } LifetimeAndTypesWithColons => { - try!(self.parse_path_segments_with_colons()) + self.parse_path_segments_with_colons()? } NoTypesAllowed => { - try!(self.parse_path_segments_without_types()) + self.parse_path_segments_without_types()? } }; path.segments.extend(segments); @@ -1771,13 +1771,13 @@ impl<'a> Parser<'a> { // A bound set is a set of type parameter bounds. let segments = match mode { LifetimeAndTypesWithoutColons => { - try!(self.parse_path_segments_without_colons()) + self.parse_path_segments_without_colons()? } LifetimeAndTypesWithColons => { - try!(self.parse_path_segments_with_colons()) + self.parse_path_segments_with_colons()? } NoTypesAllowed => { - try!(self.parse_path_segments_without_types()) + self.parse_path_segments_without_types()? } }; @@ -1800,11 +1800,11 @@ impl<'a> Parser<'a> { let mut segments = Vec::new(); loop { // First, parse an identifier. - let identifier = try!(self.parse_ident_or_self_type()); + let identifier = self.parse_ident_or_self_type()?; // Parse types, optionally. let parameters = if self.eat_lt() { - let (lifetimes, types, bindings) = try!(self.parse_generic_values_after_lt()); + let (lifetimes, types, bindings) = self.parse_generic_values_after_lt()?; ast::PathParameters::AngleBracketed(ast::AngleBracketedParameterData { lifetimes: lifetimes, @@ -1814,13 +1814,13 @@ impl<'a> Parser<'a> { } else if self.eat(&token::OpenDelim(token::Paren)) { let lo = self.last_span.lo; - let inputs = try!(self.parse_seq_to_end( + let inputs = self.parse_seq_to_end( &token::CloseDelim(token::Paren), SeqSep::trailing_allowed(token::Comma), - |p| p.parse_ty_sum())); + |p| p.parse_ty_sum())?; let output_ty = if self.eat(&token::RArrow) { - Some(try!(self.parse_ty())) + Some(self.parse_ty()?) } else { None }; @@ -1853,7 +1853,7 @@ impl<'a> Parser<'a> { let mut segments = Vec::new(); loop { // First, parse an identifier. - let identifier = try!(self.parse_ident_or_self_type()); + let identifier = self.parse_ident_or_self_type()?; // If we do not see a `::`, stop. if !self.eat(&token::ModSep) { @@ -1867,7 +1867,7 @@ impl<'a> Parser<'a> { // Check for a type segment. if self.eat_lt() { // Consumed `a::b::<`, go look for types - let (lifetimes, types, bindings) = try!(self.parse_generic_values_after_lt()); + let (lifetimes, types, bindings) = self.parse_generic_values_after_lt()?; let parameters = ast::AngleBracketedParameterData { lifetimes: lifetimes, types: P::from_vec(types), @@ -1899,7 +1899,7 @@ impl<'a> Parser<'a> { let mut segments = Vec::new(); loop { // First, parse an identifier. - let identifier = try!(self.parse_ident_or_self_type()); + let identifier = self.parse_ident_or_self_type()?; // Assemble and push the result. segments.push(ast::PathSegment { @@ -1918,7 +1918,7 @@ impl<'a> Parser<'a> { pub fn parse_opt_lifetime(&mut self) -> PResult<'a, Option<ast::Lifetime>> { match self.token { token::Lifetime(..) => { - Ok(Some(try!(self.parse_lifetime()))) + Ok(Some(self.parse_lifetime()?)) } _ => { Ok(None) @@ -1953,10 +1953,10 @@ impl<'a> Parser<'a> { loop { match self.token { token::Lifetime(_) => { - let lifetime = try!(self.parse_lifetime()); + let lifetime = self.parse_lifetime()?; let bounds = if self.eat(&token::Colon) { - try!(self.parse_lifetimes(token::BinOp(token::Plus))) + self.parse_lifetimes(token::BinOp(token::Plus))? } else { Vec::new() }; @@ -1996,7 +1996,7 @@ impl<'a> Parser<'a> { loop { match self.token { token::Lifetime(_) => { - res.push(try!(self.parse_lifetime())); + res.push(self.parse_lifetime()?); } _ => { return Ok(res); @@ -2023,10 +2023,10 @@ impl<'a> Parser<'a> { /// Parse ident COLON expr pub fn parse_field(&mut self) -> PResult<'a, Field> { let lo = self.span.lo; - let i = try!(self.parse_ident()); + let i = self.parse_ident()?; let hi = self.last_span.hi; - try!(self.expect(&token::Colon)); - let e = try!(self.parse_expr()); + self.expect(&token::Colon)?; + let e = self.parse_expr()?; Ok(ast::Field { ident: spanned(lo, hi, i), span: mk_sp(lo, e.span.hi), @@ -2152,7 +2152,7 @@ impl<'a> Parser<'a> { token::OpenDelim(token::Paren) => { self.bump(); - let attrs = try!(self.parse_inner_attributes()) + let attrs = self.parse_inner_attributes()? .into_thin_attrs() .prepend(attrs); @@ -2161,9 +2161,9 @@ impl<'a> Parser<'a> { let mut es = vec![]; let mut trailing_comma = false; while self.token != token::CloseDelim(token::Paren) { - es.push(try!(self.parse_expr())); - try!(self.commit_expr(&es.last().unwrap(), &[], - &[token::Comma, token::CloseDelim(token::Paren)])); + es.push(self.parse_expr()?); + self.commit_expr(&es.last().unwrap(), &[], + &[token::Comma, token::CloseDelim(token::Paren)])?; if self.check(&token::Comma) { trailing_comma = true; @@ -2201,7 +2201,7 @@ impl<'a> Parser<'a> { token::OpenDelim(token::Bracket) => { self.bump(); - let inner_attrs = try!(self.parse_inner_attributes()) + let inner_attrs = self.parse_inner_attributes()? .into_thin_attrs(); attrs.update(|attrs| attrs.append(inner_attrs)); @@ -2211,27 +2211,27 @@ impl<'a> Parser<'a> { ex = ExprKind::Vec(Vec::new()); } else { // Nonempty vector. - let first_expr = try!(self.parse_expr()); + let first_expr = self.parse_expr()?; if self.check(&token::Semi) { // Repeating array syntax: [ 0; 512 ] self.bump(); - let count = try!(self.parse_expr()); - try!(self.expect(&token::CloseDelim(token::Bracket))); + let count = self.parse_expr()?; + self.expect(&token::CloseDelim(token::Bracket))?; ex = ExprKind::Repeat(first_expr, count); } else if self.check(&token::Comma) { // Vector with two or more elements. self.bump(); - let remaining_exprs = try!(self.parse_seq_to_end( + let remaining_exprs = self.parse_seq_to_end( &token::CloseDelim(token::Bracket), SeqSep::trailing_allowed(token::Comma), - |p| Ok(try!(p.parse_expr())) - )); + |p| Ok(p.parse_expr()?) + )?; let mut exprs = vec!(first_expr); exprs.extend(remaining_exprs); ex = ExprKind::Vec(exprs); } else { // Vector with one element. - try!(self.expect(&token::CloseDelim(token::Bracket))); + self.expect(&token::CloseDelim(token::Bracket))?; ex = ExprKind::Vec(vec!(first_expr)); } } @@ -2240,7 +2240,7 @@ impl<'a> Parser<'a> { _ => { if self.eat_lt() { let (qself, path) = - try!(self.parse_qualified_path(LifetimeAndTypesWithColons)); + self.parse_qualified_path(LifetimeAndTypesWithColons)?; hi = path.span.hi; return Ok(self.mk_expr(lo, hi, ExprKind::Path(Some(qself), path), attrs)); } @@ -2263,7 +2263,7 @@ impl<'a> Parser<'a> { let lifetime = self.get_lifetime(); let lo = self.span.lo; self.bump(); - try!(self.expect(&token::Colon)); + self.expect(&token::Colon)?; if self.eat_keyword(keywords::While) { return self.parse_while_expr(Some(lifetime), lo, attrs) } @@ -2304,7 +2304,7 @@ impl<'a> Parser<'a> { } if self.eat_keyword(keywords::Return) { if self.token.can_begin_expr() { - let e = try!(self.parse_expr()); + let e = self.parse_expr()?; hi = e.span.hi; ex = ExprKind::Ret(Some(e)); } else { @@ -2332,18 +2332,18 @@ impl<'a> Parser<'a> { !self.check_keyword(keywords::True) && !self.check_keyword(keywords::False) { let pth = - try!(self.parse_path(LifetimeAndTypesWithColons)); + self.parse_path(LifetimeAndTypesWithColons)?; // `!`, as an operator, is prefix, so we know this isn't that if self.check(&token::Not) { // MACRO INVOCATION expression self.bump(); - let delim = try!(self.expect_open_delim()); - let tts = try!(self.parse_seq_to_end( + let delim = self.expect_open_delim()?; + let tts = self.parse_seq_to_end( &token::CloseDelim(delim), SeqSep::none(), - |p| p.parse_token_tree())); + |p| p.parse_token_tree())?; let hi = self.last_span.hi; return Ok(self.mk_mac_expr(lo, @@ -2364,7 +2364,7 @@ impl<'a> Parser<'a> { let mut base = None; let attrs = attrs.append( - try!(self.parse_inner_attributes()) + self.parse_inner_attributes()? .into_thin_attrs()); while self.token != token::CloseDelim(token::Brace) { @@ -2403,7 +2403,7 @@ impl<'a> Parser<'a> { } hi = self.span.hi; - try!(self.expect(&token::CloseDelim(token::Brace))); + self.expect(&token::CloseDelim(token::Brace))?; ex = ExprKind::Struct(pth, fields, base); return Ok(self.mk_expr(lo, hi, ex, attrs)); } @@ -2413,7 +2413,7 @@ impl<'a> Parser<'a> { ex = ExprKind::Path(None, pth); } else { // other literal expression - let lit = try!(self.parse_lit()); + let lit = self.parse_lit()?; hi = lit.span.hi; ex = ExprKind::Lit(P(lit)); } @@ -2439,12 +2439,12 @@ impl<'a> Parser<'a> { -> PResult<'a, P<Expr>> { let outer_attrs = attrs; - try!(self.expect(&token::OpenDelim(token::Brace))); + self.expect(&token::OpenDelim(token::Brace))?; - let inner_attrs = try!(self.parse_inner_attributes()).into_thin_attrs(); + let inner_attrs = self.parse_inner_attributes()?.into_thin_attrs(); let attrs = outer_attrs.append(inner_attrs); - let blk = try!(self.parse_block_tail(lo, blk_mode)); + let blk = self.parse_block_tail(lo, blk_mode)?; return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprKind::Block(blk), attrs)); } @@ -2452,10 +2452,10 @@ impl<'a> Parser<'a> { pub fn parse_dot_or_call_expr(&mut self, already_parsed_attrs: Option<ThinAttributes>) -> PResult<'a, P<Expr>> { - let attrs = try!(self.parse_or_use_outer_attributes(already_parsed_attrs)); + let attrs = self.parse_or_use_outer_attributes(already_parsed_attrs)?; let b = self.parse_bottom_expr(); - let (span, b) = try!(self.interpolated_or_expr_span(b)); + let (span, b) = self.interpolated_or_expr_span(b)?; self.parse_dot_or_call_expr_with(b, span.lo, attrs) } @@ -2498,8 +2498,8 @@ impl<'a> Parser<'a> { lo: BytePos) -> PResult<'a, P<Expr>> { let (_, tys, bindings) = if self.eat(&token::ModSep) { - try!(self.expect_lt()); - try!(self.parse_generic_values_after_lt()) + self.expect_lt()?; + self.parse_generic_values_after_lt()? } else { (Vec::new(), Vec::new(), Vec::new()) }; @@ -2512,12 +2512,12 @@ impl<'a> Parser<'a> { Ok(match self.token { // expr.f() method call. token::OpenDelim(token::Paren) => { - let mut es = try!(self.parse_unspanned_seq( + let mut es = self.parse_unspanned_seq( &token::OpenDelim(token::Paren), &token::CloseDelim(token::Paren), SeqSep::trailing_allowed(token::Comma), - |p| Ok(try!(p.parse_expr())) - )); + |p| Ok(p.parse_expr()?) + )?; let hi = self.last_span.hi; es.insert(0, self_value); @@ -2559,7 +2559,7 @@ impl<'a> Parser<'a> { hi = self.span.hi; self.bump(); - e = try!(self.parse_dot_suffix(i, mk_sp(dot_pos, hi), e, lo)); + e = self.parse_dot_suffix(i, mk_sp(dot_pos, hi), e, lo)?; } token::Literal(token::Integer(n), suf) => { let sp = self.span; @@ -2609,9 +2609,9 @@ impl<'a> Parser<'a> { self.span_err(self.span, &format!("unexpected token: `{}`", actual)); let dot_pos = self.last_span.hi; - e = try!(self.parse_dot_suffix(special_idents::invalid, + e = self.parse_dot_suffix(special_idents::invalid, mk_sp(dot_pos, dot_pos), - e, lo)); + e, lo)?; } } continue; @@ -2620,12 +2620,12 @@ impl<'a> Parser<'a> { match self.token { // expr(...) token::OpenDelim(token::Paren) => { - let es = try!(self.parse_unspanned_seq( + let es = self.parse_unspanned_seq( &token::OpenDelim(token::Paren), &token::CloseDelim(token::Paren), SeqSep::trailing_allowed(token::Comma), - |p| Ok(try!(p.parse_expr())) - )); + |p| Ok(p.parse_expr()?) + )?; hi = self.last_span.hi; let nd = self.mk_call(e, es); @@ -2636,9 +2636,9 @@ impl<'a> Parser<'a> { // Could be either an index expression or a slicing expression. token::OpenDelim(token::Bracket) => { self.bump(); - let ix = try!(self.parse_expr()); + let ix = self.parse_expr()?; hi = self.span.hi; - try!(self.commit_expr_expecting(&ix, token::CloseDelim(token::Bracket))); + self.commit_expr_expecting(&ix, token::CloseDelim(token::Bracket))?; let index = self.mk_index(e, ix); e = self.mk_expr(lo, hi, index, None) } @@ -2656,13 +2656,13 @@ impl<'a> Parser<'a> { self.bump(); if self.token == token::OpenDelim(token::Paren) { - let Spanned { node: seq, span: seq_span } = try!(self.parse_seq( + let Spanned { node: seq, span: seq_span } = self.parse_seq( &token::OpenDelim(token::Paren), &token::CloseDelim(token::Paren), SeqSep::none(), |p| p.parse_token_tree() - )); - let (sep, repeat) = try!(self.parse_sep_and_kleene_op()); + )?; + let (sep, repeat) = self.parse_sep_and_kleene_op()?; let name_num = macro_parser::count_names(&seq); return Ok(TokenTree::Sequence(mk_sp(sp.lo, seq_span.hi), Rc::new(SequenceRepetition { @@ -2677,7 +2677,7 @@ impl<'a> Parser<'a> { } else { sp = mk_sp(sp.lo, self.span.hi); let namep = match self.token { token::Ident(_, p) => p, _ => token::Plain }; - let name = try!(self.parse_ident()); + let name = self.parse_ident()?; (name, namep) } } @@ -2694,7 +2694,7 @@ impl<'a> Parser<'a> { self.bump(); sp = mk_sp(sp.lo, self.span.hi); let kindp = match self.token { token::Ident(_, p) => p, _ => token::Plain }; - let nt_kind = try!(self.parse_ident()); + let nt_kind = self.parse_ident()?; Ok(TokenTree::Token(sp, MatchNt(name, nt_kind, namep, kindp))) } else { Ok(TokenTree::Token(sp, SubstNt(name, namep))) @@ -2729,13 +2729,13 @@ impl<'a> Parser<'a> { } }; - match try!(parse_kleene_op(self)) { + match parse_kleene_op(self)? { Some(kleene_op) => return Ok((None, kleene_op)), None => {} } let separator = self.bump_and_get(); - match try!(parse_kleene_op(self)) { + match parse_kleene_op(self)? { Some(zerok) => Ok((Some(separator), zerok)), None => return Err(self.fatal("expected `*` or `+`")) } @@ -2827,7 +2827,7 @@ impl<'a> Parser<'a> { pub fn parse_all_token_trees(&mut self) -> PResult<'a, Vec<TokenTree>> { let mut tts = Vec::new(); while self.token != token::Eof { - tts.push(try!(self.parse_token_tree())); + tts.push(self.parse_token_tree()?); } Ok(tts) } @@ -2836,7 +2836,7 @@ impl<'a> Parser<'a> { pub fn parse_prefix_expr(&mut self, already_parsed_attrs: Option<ThinAttributes>) -> PResult<'a, P<Expr>> { - let attrs = try!(self.parse_or_use_outer_attributes(already_parsed_attrs)); + let attrs = self.parse_or_use_outer_attributes(already_parsed_attrs)?; let lo = self.span.lo; let hi; // Note: when adding new unary operators, don't forget to adjust Token::can_begin_expr() @@ -2844,39 +2844,39 @@ impl<'a> Parser<'a> { token::Not => { self.bump(); let e = self.parse_prefix_expr(None); - let (span, e) = try!(self.interpolated_or_expr_span(e)); + let (span, e) = self.interpolated_or_expr_span(e)?; hi = span.hi; self.mk_unary(UnOp::Not, e) } token::BinOp(token::Minus) => { self.bump(); let e = self.parse_prefix_expr(None); - let (span, e) = try!(self.interpolated_or_expr_span(e)); + let (span, e) = self.interpolated_or_expr_span(e)?; hi = span.hi; self.mk_unary(UnOp::Neg, e) } token::BinOp(token::Star) => { self.bump(); let e = self.parse_prefix_expr(None); - let (span, e) = try!(self.interpolated_or_expr_span(e)); + let (span, e) = self.interpolated_or_expr_span(e)?; hi = span.hi; self.mk_unary(UnOp::Deref, e) } token::BinOp(token::And) | token::AndAnd => { - try!(self.expect_and()); - let m = try!(self.parse_mutability()); + self.expect_and()?; + let m = self.parse_mutability()?; let e = self.parse_prefix_expr(None); - let (span, e) = try!(self.interpolated_or_expr_span(e)); + let (span, e) = self.interpolated_or_expr_span(e)?; hi = span.hi; ExprKind::AddrOf(m, e) } token::Ident(..) if self.token.is_keyword(keywords::In) => { self.bump(); - let place = try!(self.parse_expr_res( + let place = self.parse_expr_res( Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None, - )); - let blk = try!(self.parse_block()); + )?; + let blk = self.parse_block()?; let span = blk.span; hi = span.hi; let blk_expr = self.mk_expr(span.lo, span.hi, ExprKind::Block(blk), @@ -2886,7 +2886,7 @@ impl<'a> Parser<'a> { token::Ident(..) if self.token.is_keyword(keywords::Box) => { self.bump(); let e = self.parse_prefix_expr(None); - let (span, e) = try!(self.interpolated_or_expr_span(e)); + let (span, e) = self.interpolated_or_expr_span(e)?; hi = span.hi; ExprKind::Box(e) } @@ -2920,7 +2920,7 @@ impl<'a> Parser<'a> { if self.token == token::DotDot || self.token == token::DotDotDot { return self.parse_prefix_range_expr(attrs); } else { - try!(self.parse_prefix_expr(attrs)) + self.parse_prefix_expr(attrs)? } }; @@ -2952,12 +2952,12 @@ impl<'a> Parser<'a> { } // Special cases: if op == AssocOp::As { - let rhs = try!(self.parse_ty()); + let rhs = self.parse_ty()?; lhs = self.mk_expr(lhs_span.lo, rhs.span.hi, ExprKind::Cast(lhs, rhs), None); continue } else if op == AssocOp::Colon { - let rhs = try!(self.parse_ty()); + let rhs = self.parse_ty()?; lhs = self.mk_expr(lhs_span.lo, rhs.span.hi, ExprKind::Type(lhs, rhs), None); continue @@ -2990,7 +2990,7 @@ impl<'a> Parser<'a> { break } - let rhs = try!(match op.fixity() { + let rhs = match op.fixity() { Fixity::Right => self.with_res( restrictions - Restrictions::RESTRICTION_STMT_EXPR, |this| { @@ -3011,7 +3011,7 @@ impl<'a> Parser<'a> { this.parse_assoc_expr_with(op.precedence() + 1, LhsExpr::NotYetParsed) }), - }); + }?; lhs = match op { AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | @@ -3087,19 +3087,19 @@ impl<'a> Parser<'a> { -> PResult<'a, P<Expr>> { debug_assert!(self.token == token::DotDot || self.token == token::DotDotDot); let tok = self.token.clone(); - let attrs = try!(self.parse_or_use_outer_attributes(already_parsed_attrs)); + let attrs = self.parse_or_use_outer_attributes(already_parsed_attrs)?; let lo = self.span.lo; let mut hi = self.span.hi; self.bump(); let opt_end = if self.is_at_start_of_range_notation_rhs() { // RHS must be parsed with more associativity than the dots. let next_prec = AssocOp::from_token(&tok).unwrap().precedence() + 1; - Some(try!(self.parse_assoc_expr_with(next_prec, + Some(self.parse_assoc_expr_with(next_prec, LhsExpr::NotYetParsed) .map(|x|{ hi = x.span.hi; x - }))) + })?) } else { None }; @@ -3131,12 +3131,12 @@ impl<'a> Parser<'a> { return self.parse_if_let_expr(attrs); } let lo = self.last_span.lo; - let cond = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)); - let thn = try!(self.parse_block()); + let cond = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?; + let thn = self.parse_block()?; let mut els: Option<P<Expr>> = None; let mut hi = thn.span.hi; if self.eat_keyword(keywords::Else) { - let elexpr = try!(self.parse_else_expr()); + let elexpr = self.parse_else_expr()?; hi = elexpr.span.hi; els = Some(elexpr); } @@ -3147,13 +3147,13 @@ impl<'a> Parser<'a> { pub fn parse_if_let_expr(&mut self, attrs: ThinAttributes) -> PResult<'a, P<Expr>> { let lo = self.last_span.lo; - try!(self.expect_keyword(keywords::Let)); - let pat = try!(self.parse_pat()); - try!(self.expect(&token::Eq)); - let expr = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)); - let thn = try!(self.parse_block()); + self.expect_keyword(keywords::Let)?; + let pat = self.parse_pat()?; + self.expect(&token::Eq)?; + let expr = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?; + let thn = self.parse_block()?; let (hi, els) = if self.eat_keyword(keywords::Else) { - let expr = try!(self.parse_else_expr()); + let expr = self.parse_else_expr()?; (expr.span.hi, Some(expr)) } else { (thn.span.hi, None) @@ -3167,12 +3167,12 @@ impl<'a> Parser<'a> { attrs: ThinAttributes) -> PResult<'a, P<Expr>> { - let decl = try!(self.parse_fn_block_decl()); + let decl = self.parse_fn_block_decl()?; let body = match decl.output { FunctionRetTy::Default(_) => { // If no explicit return type is given, parse any // expr and wrap it up in a dummy block: - let body_expr = try!(self.parse_expr()); + let body_expr = self.parse_expr()?; P(ast::Block { id: ast::DUMMY_NODE_ID, stmts: vec![], @@ -3184,7 +3184,7 @@ impl<'a> Parser<'a> { _ => { // If an explicit return type is given, require a // block to appear (RFC 968). - try!(self.parse_block()) + self.parse_block()? } }; @@ -3199,7 +3199,7 @@ impl<'a> Parser<'a> { if self.eat_keyword(keywords::If) { return self.parse_if_expr(None); } else { - let blk = try!(self.parse_block()); + let blk = self.parse_block()?; return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprKind::Block(blk), None)); } } @@ -3210,10 +3210,10 @@ impl<'a> Parser<'a> { attrs: ThinAttributes) -> PResult<'a, P<Expr>> { // Parse: `for <src_pat> in <src_expr> <src_loop_block>` - let pat = try!(self.parse_pat()); - try!(self.expect_keyword(keywords::In)); - let expr = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)); - let (iattrs, loop_block) = try!(self.parse_inner_attrs_and_block()); + let pat = self.parse_pat()?; + self.expect_keyword(keywords::In)?; + let expr = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?; + let (iattrs, loop_block) = self.parse_inner_attrs_and_block()?; let attrs = attrs.append(iattrs.into_thin_attrs()); let hi = self.last_span.hi; @@ -3230,8 +3230,8 @@ impl<'a> Parser<'a> { if self.token.is_keyword(keywords::Let) { return self.parse_while_let_expr(opt_ident, span_lo, attrs); } - let cond = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)); - let (iattrs, body) = try!(self.parse_inner_attrs_and_block()); + let cond = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?; + let (iattrs, body) = self.parse_inner_attrs_and_block()?; let attrs = attrs.append(iattrs.into_thin_attrs()); let hi = body.span.hi; return Ok(self.mk_expr(span_lo, hi, ExprKind::While(cond, body, opt_ident), @@ -3242,11 +3242,11 @@ impl<'a> Parser<'a> { pub fn parse_while_let_expr(&mut self, opt_ident: Option<ast::Ident>, span_lo: BytePos, attrs: ThinAttributes) -> PResult<'a, P<Expr>> { - try!(self.expect_keyword(keywords::Let)); - let pat = try!(self.parse_pat()); - try!(self.expect(&token::Eq)); - let expr = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)); - let (iattrs, body) = try!(self.parse_inner_attrs_and_block()); + self.expect_keyword(keywords::Let)?; + let pat = self.parse_pat()?; + self.expect(&token::Eq)?; + let expr = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?; + let (iattrs, body) = self.parse_inner_attrs_and_block()?; let attrs = attrs.append(iattrs.into_thin_attrs()); let hi = body.span.hi; return Ok(self.mk_expr(span_lo, hi, ExprKind::WhileLet(pat, expr, body, opt_ident), attrs)); @@ -3256,7 +3256,7 @@ impl<'a> Parser<'a> { pub fn parse_loop_expr(&mut self, opt_ident: Option<ast::Ident>, span_lo: BytePos, attrs: ThinAttributes) -> PResult<'a, P<Expr>> { - let (iattrs, body) = try!(self.parse_inner_attrs_and_block()); + let (iattrs, body) = self.parse_inner_attrs_and_block()?; let attrs = attrs.append(iattrs.into_thin_attrs()); let hi = body.span.hi; Ok(self.mk_expr(span_lo, hi, ExprKind::Loop(body, opt_ident), attrs)) @@ -3266,8 +3266,8 @@ impl<'a> Parser<'a> { fn parse_match_expr(&mut self, attrs: ThinAttributes) -> PResult<'a, P<Expr>> { let match_span = self.last_span; let lo = self.last_span.lo; - let discriminant = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, - None)); + let discriminant = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, + None)?; if let Err(mut e) = self.commit_expr_expecting(&discriminant, token::OpenDelim(token::Brace)) { if self.token == token::Token::Semi { @@ -3276,7 +3276,7 @@ impl<'a> Parser<'a> { return Err(e) } let attrs = attrs.append( - try!(self.parse_inner_attributes()).into_thin_attrs()); + self.parse_inner_attributes()?.into_thin_attrs()); let mut arms: Vec<Arm> = Vec::new(); while self.token != token::CloseDelim(token::Brace) { match self.parse_arm() { @@ -3301,21 +3301,21 @@ impl<'a> Parser<'a> { pub fn parse_arm(&mut self) -> PResult<'a, Arm> { maybe_whole!(no_clone self, NtArm); - let attrs = try!(self.parse_outer_attributes()); - let pats = try!(self.parse_pats()); + let attrs = self.parse_outer_attributes()?; + let pats = self.parse_pats()?; let mut guard = None; if self.eat_keyword(keywords::If) { - guard = Some(try!(self.parse_expr())); + guard = Some(self.parse_expr()?); } - try!(self.expect(&token::FatArrow)); - let expr = try!(self.parse_expr_res(Restrictions::RESTRICTION_STMT_EXPR, None)); + self.expect(&token::FatArrow)?; + let expr = self.parse_expr_res(Restrictions::RESTRICTION_STMT_EXPR, None)?; let require_comma = !classify::expr_is_simple_block(&expr) && self.token != token::CloseDelim(token::Brace); if require_comma { - try!(self.commit_expr(&expr, &[token::Comma], &[token::CloseDelim(token::Brace)])); + self.commit_expr(&expr, &[token::Comma], &[token::CloseDelim(token::Brace)])?; } else { self.eat(&token::Comma); } @@ -3358,7 +3358,7 @@ impl<'a> Parser<'a> { fn parse_initializer(&mut self) -> PResult<'a, Option<P<Expr>>> { if self.check(&token::Eq) { self.bump(); - Ok(Some(try!(self.parse_expr()))) + Ok(Some(self.parse_expr()?)) } else { Ok(None) } @@ -3368,7 +3368,7 @@ impl<'a> Parser<'a> { fn parse_pats(&mut self) -> PResult<'a, Vec<P<Pat>>> { let mut pats = Vec::new(); loop { - pats.push(try!(self.parse_pat())); + pats.push(self.parse_pat()?); if self.check(&token::BinOp(token::Or)) { self.bump();} else { return Ok(pats); } }; @@ -3377,15 +3377,15 @@ impl<'a> Parser<'a> { fn parse_pat_tuple_elements(&mut self) -> PResult<'a, Vec<P<Pat>>> { let mut fields = vec![]; if !self.check(&token::CloseDelim(token::Paren)) { - fields.push(try!(self.parse_pat())); + fields.push(self.parse_pat()?); if self.look_ahead(1, |t| *t != token::CloseDelim(token::Paren)) { while self.eat(&token::Comma) && !self.check(&token::CloseDelim(token::Paren)) { - fields.push(try!(self.parse_pat())); + fields.push(self.parse_pat()?); } } if fields.len() == 1 { - try!(self.expect(&token::Comma)); + self.expect(&token::Comma)?; } } Ok(fields) @@ -3404,7 +3404,7 @@ impl<'a> Parser<'a> { if first { first = false; } else { - try!(self.expect(&token::Comma)); + self.expect(&token::Comma)?; if self.token == token::CloseDelim(token::Bracket) && (before_slice || !after.is_empty()) { @@ -3429,7 +3429,7 @@ impl<'a> Parser<'a> { } } - let subpat = try!(self.parse_pat()); + let subpat = self.parse_pat()?; if before_slice && self.check(&token::DotDot) { self.bump(); slice = Some(subpat); @@ -3453,7 +3453,7 @@ impl<'a> Parser<'a> { if first { first = false; } else { - try!(self.expect(&token::Comma)); + self.expect(&token::Comma)?; // accept trailing commas if self.check(&token::CloseDelim(token::Brace)) { break } } @@ -3475,9 +3475,9 @@ impl<'a> Parser<'a> { // Check if a colon exists one ahead. This means we're parsing a fieldname. let (subpat, fieldname, is_shorthand) = if self.look_ahead(1, |t| t == &token::Colon) { // Parsing a pattern of the form "fieldname: pat" - let fieldname = try!(self.parse_ident()); + let fieldname = self.parse_ident()?; self.bump(); - let pat = try!(self.parse_pat()); + let pat = self.parse_pat()?; hi = pat.span.hi; (pat, fieldname, false) } else { @@ -3486,7 +3486,7 @@ impl<'a> Parser<'a> { let boxed_span_lo = self.span.lo; let is_ref = self.eat_keyword(keywords::Ref); let is_mut = self.eat_keyword(keywords::Mut); - let fieldname = try!(self.parse_ident()); + let fieldname = self.parse_ident()?; hi = self.last_span.hi; let bind_type = match (is_ref, is_mut) { @@ -3528,11 +3528,11 @@ impl<'a> Parser<'a> { let (qself, path) = if self.eat_lt() { // Parse a qualified path let (qself, path) = - try!(self.parse_qualified_path(NoTypesAllowed)); + self.parse_qualified_path(NoTypesAllowed)?; (Some(qself), path) } else { // Parse an unqualified path - (None, try!(self.parse_path(LifetimeAndTypesWithColons))) + (None, self.parse_path(LifetimeAndTypesWithColons)?) }; let hi = self.last_span.hi; Ok(self.mk_expr(lo, hi, ExprKind::Path(qself, path), None)) @@ -3561,41 +3561,41 @@ impl<'a> Parser<'a> { } token::BinOp(token::And) | token::AndAnd => { // Parse &pat / &mut pat - try!(self.expect_and()); - let mutbl = try!(self.parse_mutability()); + self.expect_and()?; + let mutbl = self.parse_mutability()?; if let token::Lifetime(ident) = self.token { return Err(self.fatal(&format!("unexpected lifetime `{}` in pattern", ident))); } - let subpat = try!(self.parse_pat()); + let subpat = self.parse_pat()?; pat = PatKind::Ref(subpat, mutbl); } token::OpenDelim(token::Paren) => { // Parse (pat,pat,pat,...) as tuple pattern self.bump(); - let fields = try!(self.parse_pat_tuple_elements()); - try!(self.expect(&token::CloseDelim(token::Paren))); + let fields = self.parse_pat_tuple_elements()?; + self.expect(&token::CloseDelim(token::Paren))?; pat = PatKind::Tup(fields); } token::OpenDelim(token::Bracket) => { // Parse [pat,pat,...] as slice pattern self.bump(); - let (before, slice, after) = try!(self.parse_pat_vec_elements()); - try!(self.expect(&token::CloseDelim(token::Bracket))); + let (before, slice, after) = self.parse_pat_vec_elements()?; + self.expect(&token::CloseDelim(token::Bracket))?; pat = PatKind::Vec(before, slice, after); } _ => { // At this point, token != _, &, &&, (, [ if self.eat_keyword(keywords::Mut) { // Parse mut ident @ pat - pat = try!(self.parse_pat_ident(BindingMode::ByValue(Mutability::Mutable))); + pat = self.parse_pat_ident(BindingMode::ByValue(Mutability::Mutable))?; } else if self.eat_keyword(keywords::Ref) { // Parse ref ident @ pat / ref mut ident @ pat - let mutbl = try!(self.parse_mutability()); - pat = try!(self.parse_pat_ident(BindingMode::ByRef(mutbl))); + let mutbl = self.parse_mutability()?; + pat = self.parse_pat_ident(BindingMode::ByRef(mutbl))?; } else if self.eat_keyword(keywords::Box) { // Parse box pat - let subpat = try!(self.parse_pat()); + let subpat = self.parse_pat()?; pat = PatKind::Box(subpat); } else if self.is_path_start() { // Parse pattern starting with a path @@ -3607,13 +3607,13 @@ impl<'a> Parser<'a> { // Plain idents have some extra abilities here compared to general paths if self.look_ahead(1, |t| *t == token::Not) { // Parse macro invocation - let ident = try!(self.parse_ident()); + let ident = self.parse_ident()?; let ident_span = self.last_span; let path = ident_to_path(ident_span, ident); self.bump(); - let delim = try!(self.expect_open_delim()); - let tts = try!(self.parse_seq_to_end(&token::CloseDelim(delim), - SeqSep::none(), |p| p.parse_token_tree())); + let delim = self.expect_open_delim()?; + let tts = self.parse_seq_to_end(&token::CloseDelim(delim), + SeqSep::none(), |p| p.parse_token_tree())?; let mac = Mac_ { path: path, tts: tts, ctxt: EMPTY_CTXT }; pat = PatKind::Mac(codemap::Spanned {node: mac, span: mk_sp(lo, self.last_span.hi)}); @@ -3622,17 +3622,17 @@ impl<'a> Parser<'a> { // This can give false positives and parse nullary enums, // they are dealt with later in resolve let binding_mode = BindingMode::ByValue(Mutability::Immutable); - pat = try!(self.parse_pat_ident(binding_mode)); + pat = self.parse_pat_ident(binding_mode)?; } } else { let (qself, path) = if self.eat_lt() { // Parse a qualified path let (qself, path) = - try!(self.parse_qualified_path(NoTypesAllowed)); + self.parse_qualified_path(NoTypesAllowed)?; (Some(qself), path) } else { // Parse an unqualified path - (None, try!(self.parse_path(LifetimeAndTypesWithColons))) + (None, self.parse_path(LifetimeAndTypesWithColons)?) }; match self.token { token::DotDotDot => { @@ -3640,7 +3640,7 @@ impl<'a> Parser<'a> { let hi = self.last_span.hi; let begin = self.mk_expr(lo, hi, ExprKind::Path(qself, path), None); self.bump(); - let end = try!(self.parse_pat_range_end()); + let end = self.parse_pat_range_end()?; pat = PatKind::Range(begin, end); } token::OpenDelim(token::Brace) => { @@ -3666,14 +3666,14 @@ impl<'a> Parser<'a> { // This is a "top constructor only" pat self.bump(); self.bump(); - try!(self.expect(&token::CloseDelim(token::Paren))); + self.expect(&token::CloseDelim(token::Paren))?; pat = PatKind::TupleStruct(path, None); } else { - let args = try!(self.parse_enum_variant_seq( + let args = self.parse_enum_variant_seq( &token::OpenDelim(token::Paren), &token::CloseDelim(token::Paren), SeqSep::trailing_allowed(token::Comma), - |p| p.parse_pat())); + |p| p.parse_pat())?; pat = PatKind::TupleStruct(path, Some(args)); } } @@ -3689,9 +3689,9 @@ impl<'a> Parser<'a> { } } else { // Try to parse everything else as literal with optional minus - let begin = try!(self.parse_pat_literal_maybe_minus()); + let begin = self.parse_pat_literal_maybe_minus()?; if self.eat(&token::DotDotDot) { - let end = try!(self.parse_pat_range_end()); + let end = self.parse_pat_range_end()?; pat = PatKind::Range(begin, end); } else { pat = PatKind::Lit(begin); @@ -3720,11 +3720,11 @@ impl<'a> Parser<'a> { return Err(self.span_fatal(span, &format!("expected identifier, found `{}`", tok_str))) } - let ident = try!(self.parse_ident()); + let ident = self.parse_ident()?; let last_span = self.last_span; let name = codemap::Spanned{span: last_span, node: ident}; let sub = if self.eat(&token::At) { - Some(try!(self.parse_pat())) + Some(self.parse_pat()?) } else { None }; @@ -3748,13 +3748,13 @@ impl<'a> Parser<'a> { /// Parse a local variable declaration fn parse_local(&mut self, attrs: ThinAttributes) -> PResult<'a, P<Local>> { let lo = self.span.lo; - let pat = try!(self.parse_pat()); + let pat = self.parse_pat()?; let mut ty = None; if self.eat(&token::Colon) { - ty = Some(try!(self.parse_ty_sum())); + ty = Some(self.parse_ty_sum()?); } - let init = try!(self.parse_initializer()); + let init = self.parse_initializer()?; Ok(P(ast::Local { ty: ty, pat: pat, @@ -3768,7 +3768,7 @@ impl<'a> Parser<'a> { /// Parse a "let" stmt fn parse_let(&mut self, attrs: ThinAttributes) -> PResult<'a, P<Decl>> { let lo = self.span.lo; - let local = try!(self.parse_local(attrs)); + let local = self.parse_local(attrs)?; Ok(P(spanned(lo, self.last_span.hi, DeclKind::Local(local)))) } @@ -3782,9 +3782,9 @@ impl<'a> Parser<'a> { if !self.token.is_plain_ident() { return Err(self.fatal("expected ident")); } - let name = try!(self.parse_ident()); - try!(self.expect(&token::Colon)); - let ty = try!(self.parse_ty_sum()); + let name = self.parse_ident()?; + self.expect(&token::Colon)?; + let ty = self.parse_ty_sum()?; Ok(spanned(lo, self.last_span.hi, ast::StructField_ { kind: NamedField(name, pr), id: ast::DUMMY_NODE_ID, @@ -3875,12 +3875,12 @@ impl<'a> Parser<'a> { fn parse_stmt_without_recovery(&mut self) -> PResult<'a, Option<Stmt>> { maybe_whole!(Some deref self, NtStmt); - let attrs = try!(self.parse_outer_attributes()); + let attrs = self.parse_outer_attributes()?; let lo = self.span.lo; Ok(Some(if self.check_keyword(keywords::Let) { - try!(self.expect_keyword(keywords::Let)); - let decl = try!(self.parse_let(attrs.into_thin_attrs())); + self.expect_keyword(keywords::Let)?; + let decl = self.parse_let(attrs.into_thin_attrs())?; let hi = decl.span.hi; let stmt = StmtKind::Decl(decl, ast::DUMMY_NODE_ID); spanned(lo, hi, stmt) @@ -3891,12 +3891,12 @@ impl<'a> Parser<'a> { // Potential trouble: if we allow macros with paths instead of // idents, we'd need to look ahead past the whole path here... - let pth = try!(self.parse_path(NoTypesAllowed)); + let pth = self.parse_path(NoTypesAllowed)?; self.bump(); let id = match self.token { token::OpenDelim(_) => token::special_idents::invalid, // no special identifier - _ => try!(self.parse_ident()), + _ => self.parse_ident()?, }; // check that we're pointing at delimiters (need to check @@ -3919,12 +3919,12 @@ impl<'a> Parser<'a> { }, }; - let tts = try!(self.parse_unspanned_seq( + let tts = self.parse_unspanned_seq( &token::OpenDelim(delim), &token::CloseDelim(delim), SeqSep::none(), |p| p.parse_token_tree() - )); + )?; let hi = self.last_span.hi; let style = if delim == token::Brace { @@ -3962,8 +3962,8 @@ impl<'a> Parser<'a> { } else { // FIXME: Bad copy of attrs let restrictions = self.restrictions | Restrictions::NO_NONINLINE_MOD; - match try!(self.with_res(restrictions, - |this| this.parse_item_(attrs.clone(), false, true))) { + match self.with_res(restrictions, + |this| this.parse_item_(attrs.clone(), false, true))? { Some(i) => { let hi = i.span.hi; let decl = P(spanned(lo, hi, DeclKind::Item(i))); @@ -3990,8 +3990,8 @@ impl<'a> Parser<'a> { } // Remainder are line-expr stmts. - let e = try!(self.parse_expr_res( - Restrictions::RESTRICTION_STMT_EXPR, Some(attrs.into_thin_attrs()))); + let e = self.parse_expr_res( + Restrictions::RESTRICTION_STMT_EXPR, Some(attrs.into_thin_attrs()))?; let hi = e.span.hi; let stmt = StmtKind::Expr(e, ast::DUMMY_NODE_ID); spanned(lo, hi, stmt) @@ -4028,9 +4028,9 @@ impl<'a> Parser<'a> { maybe_whole!(pair_empty self, NtBlock); let lo = self.span.lo; - try!(self.expect(&token::OpenDelim(token::Brace))); - Ok((try!(self.parse_inner_attributes()), - try!(self.parse_block_tail(lo, BlockCheckMode::Default)))) + self.expect(&token::OpenDelim(token::Brace))?; + Ok((self.parse_inner_attributes()?, + self.parse_block_tail(lo, BlockCheckMode::Default)?)) } /// Parse the rest of a block expression or function body @@ -4048,7 +4048,7 @@ impl<'a> Parser<'a> { }; match node { StmtKind::Expr(e, _) => { - try!(self.handle_expression_like_statement(e, span, &mut stmts, &mut expr)); + self.handle_expression_like_statement(e, span, &mut stmts, &mut expr)?; } StmtKind::Mac(mac, MacStmtStyle::NoBraces, attrs) => { // statement macro without braces; might be an @@ -4066,13 +4066,13 @@ impl<'a> Parser<'a> { mac.and_then(|m| m.node), None); let lo = e.span.lo; - let e = try!(self.parse_dot_or_call_expr_with(e, lo, attrs)); - let e = try!(self.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(e))); - try!(self.handle_expression_like_statement( + let e = self.parse_dot_or_call_expr_with(e, lo, attrs)?; + let e = self.parse_assoc_expr_with(0, LhsExpr::AlreadyParsed(e))?; + self.handle_expression_like_statement( e, span, &mut stmts, - &mut expr)); + &mut expr)?; } } } @@ -4104,7 +4104,7 @@ impl<'a> Parser<'a> { _ => { // all other kinds of statements: let mut hi = span.hi; if classify::stmt_ends_with_semi(&node) { - try!(self.commit_stmt_expecting(token::Semi)); + self.commit_stmt_expecting(token::Semi)?; hi = self.last_span.hi; } @@ -4205,7 +4205,7 @@ impl<'a> Parser<'a> { self.bump(); } token::ModSep | token::Ident(..) => { - let poly_trait_ref = try!(self.parse_poly_trait_ref()); + let poly_trait_ref = self.parse_poly_trait_ref()?; let modifier = if ate_question { if mode == BoundParsingMode::Modified { TraitBoundModifier::Maybe @@ -4233,13 +4233,13 @@ impl<'a> Parser<'a> { /// Matches typaram = IDENT (`?` unbound)? optbounds ( EQ ty )? fn parse_ty_param(&mut self) -> PResult<'a, TyParam> { let span = self.span; - let ident = try!(self.parse_ident()); + let ident = self.parse_ident()?; - let bounds = try!(self.parse_colon_then_ty_param_bounds(BoundParsingMode::Modified)); + let bounds = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Modified)?; let default = if self.check(&token::Eq) { self.bump(); - Some(try!(self.parse_ty_sum())) + Some(self.parse_ty_sum()?) } else { None }; @@ -4264,11 +4264,11 @@ impl<'a> Parser<'a> { maybe_whole!(self, NtGenerics); if self.eat(&token::Lt) { - let lifetime_defs = try!(self.parse_lifetime_defs()); + let lifetime_defs = self.parse_lifetime_defs()?; let mut seen_default = false; - let ty_params = try!(self.parse_seq_to_gt(Some(token::Comma), |p| { - try!(p.forbid_lifetime()); - let ty_param = try!(p.parse_ty_param()); + let ty_params = self.parse_seq_to_gt(Some(token::Comma), |p| { + p.forbid_lifetime()?; + let ty_param = p.parse_ty_param()?; if ty_param.default.is_some() { seen_default = true; } else if seen_default { @@ -4277,7 +4277,7 @@ impl<'a> Parser<'a> { "type parameters with a default must be trailing"); } Ok(ty_param) - })); + })?; Ok(ast::Generics { lifetimes: lifetime_defs, ty_params: ty_params, @@ -4295,7 +4295,7 @@ impl<'a> Parser<'a> { Vec<P<Ty>>, Vec<TypeBinding>)> { let span_lo = self.span.lo; - let lifetimes = try!(self.parse_lifetimes(token::Comma)); + let lifetimes = self.parse_lifetimes(token::Comma)?; let missing_comma = !lifetimes.is_empty() && !self.token.is_like_gt() && @@ -4327,17 +4327,17 @@ impl<'a> Parser<'a> { } // First parse types. - let (types, returned) = try!(self.parse_seq_to_gt_or_return( + let (types, returned) = self.parse_seq_to_gt_or_return( Some(token::Comma), |p| { - try!(p.forbid_lifetime()); + p.forbid_lifetime()?; if p.look_ahead(1, |t| t == &token::Eq) { Ok(None) } else { - Ok(Some(try!(p.parse_ty_sum()))) + Ok(Some(p.parse_ty_sum()?)) } } - )); + )?; // If we found the `>`, don't continue. if !returned { @@ -4345,18 +4345,18 @@ impl<'a> Parser<'a> { } // Then parse type bindings. - let bindings = try!(self.parse_seq_to_gt( + let bindings = self.parse_seq_to_gt( Some(token::Comma), |p| { - try!(p.forbid_lifetime()); + p.forbid_lifetime()?; let lo = p.span.lo; - let ident = try!(p.parse_ident()); + let ident = p.parse_ident()?; let found_eq = p.eat(&token::Eq); if !found_eq { let span = p.span; p.span_warn(span, "whoops, no =?"); } - let ty = try!(p.parse_ty()); + let ty = p.parse_ty()?; let hi = ty.span.hi; let span = mk_sp(lo, hi); return Ok(TypeBinding{id: ast::DUMMY_NODE_ID, @@ -4365,7 +4365,7 @@ impl<'a> Parser<'a> { span: span, }); } - )); + )?; Ok((lifetimes, types.into_vec(), bindings.into_vec())) } @@ -4405,12 +4405,12 @@ impl<'a> Parser<'a> { token::Lifetime(..) => { let bounded_lifetime = - try!(self.parse_lifetime()); + self.parse_lifetime()?; self.eat(&token::Colon); let bounds = - try!(self.parse_lifetimes(token::BinOp(token::Plus))); + self.parse_lifetimes(token::BinOp(token::Plus))?; let hi = self.last_span.hi; let span = mk_sp(lo, hi); @@ -4429,18 +4429,18 @@ impl<'a> Parser<'a> { _ => { let bound_lifetimes = if self.eat_keyword(keywords::For) { // Higher ranked constraint. - try!(self.expect(&token::Lt)); - let lifetime_defs = try!(self.parse_lifetime_defs()); - try!(self.expect_gt()); + self.expect(&token::Lt)?; + let lifetime_defs = self.parse_lifetime_defs()?; + self.expect_gt()?; lifetime_defs } else { vec![] }; - let bounded_ty = try!(self.parse_ty()); + let bounded_ty = self.parse_ty()?; if self.eat(&token::Colon) { - let bounds = try!(self.parse_ty_param_bounds(BoundParsingMode::Bare)); + let bounds = self.parse_ty_param_bounds(BoundParsingMode::Bare)?; let hi = self.last_span.hi; let span = mk_sp(lo, hi); @@ -4503,7 +4503,7 @@ impl<'a> Parser<'a> { let sp = self.span; let mut variadic = false; let args: Vec<Option<Arg>> = - try!(self.parse_unspanned_seq( + self.parse_unspanned_seq( &token::OpenDelim(token::Paren), &token::CloseDelim(token::Paren), SeqSep::trailing_allowed(token::Comma), @@ -4534,7 +4534,7 @@ impl<'a> Parser<'a> { } } } - )); + )?; let args: Vec<_> = args.into_iter().filter_map(|x| x).collect(); @@ -4549,8 +4549,8 @@ impl<'a> Parser<'a> { /// Parse the argument list and result type of a function declaration pub fn parse_fn_decl(&mut self, allow_variadic: bool) -> PResult<'a, P<FnDecl>> { - let (args, variadic) = try!(self.parse_fn_args(true, allow_variadic)); - let ret_ty = try!(self.parse_ret_ty()); + let (args, variadic) = self.parse_fn_args(true, allow_variadic)?; + let ret_ty = self.parse_ret_ty()?; Ok(P(FnDecl { inputs: args, @@ -4620,31 +4620,31 @@ impl<'a> Parser<'a> { if this.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) { this.bump(); - Ok(SelfKind::Region(None, Mutability::Immutable, try!(this.expect_self_ident()))) + Ok(SelfKind::Region(None, Mutability::Immutable, this.expect_self_ident()?)) } else if this.look_ahead(1, |t| t.is_mutability()) && this.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) { this.bump(); - let mutability = try!(this.parse_mutability()); - Ok(SelfKind::Region(None, mutability, try!(this.expect_self_ident()))) + let mutability = this.parse_mutability()?; + Ok(SelfKind::Region(None, mutability, this.expect_self_ident()?)) } else if this.look_ahead(1, |t| t.is_lifetime()) && this.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) { this.bump(); - let lifetime = try!(this.parse_lifetime()); - let ident = try!(this.expect_self_ident()); + let lifetime = this.parse_lifetime()?; + let ident = this.expect_self_ident()?; Ok(SelfKind::Region(Some(lifetime), Mutability::Immutable, ident)) } else if this.look_ahead(1, |t| t.is_lifetime()) && this.look_ahead(2, |t| t.is_mutability()) && this.look_ahead(3, |t| t.is_keyword(keywords::SelfValue)) { this.bump(); - let lifetime = try!(this.parse_lifetime()); - let mutability = try!(this.parse_mutability()); - Ok(SelfKind::Region(Some(lifetime), mutability, try!(this.expect_self_ident()))) + let lifetime = this.parse_lifetime()?; + let mutability = this.parse_mutability()?; + Ok(SelfKind::Region(Some(lifetime), mutability, this.expect_self_ident()?)) } else { Ok(SelfKind::Static) } } - try!(self.expect(&token::OpenDelim(token::Paren))); + self.expect(&token::OpenDelim(token::Paren))?; // A bit of complexity and lookahead is needed here in order to be // backwards compatible. @@ -4655,7 +4655,7 @@ impl<'a> Parser<'a> { let mut mutbl_self = Mutability::Immutable; let explicit_self = match self.token { token::BinOp(token::And) => { - let eself = try!(maybe_parse_borrowed_explicit_self(self)); + let eself = maybe_parse_borrowed_explicit_self(self)?; self_ident_lo = self.last_span.lo; self_ident_hi = self.last_span.hi; eself @@ -4665,7 +4665,7 @@ impl<'a> Parser<'a> { // emitting cryptic "unexpected token" errors. self.bump(); let _mutability = if self.token.is_mutability() { - try!(self.parse_mutability()) + self.parse_mutability()? } else { Mutability::Immutable }; @@ -4679,24 +4679,24 @@ impl<'a> Parser<'a> { } token::Ident(..) => { if self.is_self_ident() { - let self_ident = try!(self.expect_self_ident()); + let self_ident = self.expect_self_ident()?; // Determine whether this is the fully explicit form, `self: // TYPE`. if self.eat(&token::Colon) { - SelfKind::Explicit(try!(self.parse_ty_sum()), self_ident) + SelfKind::Explicit(self.parse_ty_sum()?, self_ident) } else { SelfKind::Value(self_ident) } } else if self.token.is_mutability() && self.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) { - mutbl_self = try!(self.parse_mutability()); - let self_ident = try!(self.expect_self_ident()); + mutbl_self = self.parse_mutability()?; + let self_ident = self.expect_self_ident()?; // Determine whether this is the fully explicit form, // `self: TYPE`. if self.eat(&token::Colon) { - SelfKind::Explicit(try!(self.parse_ty_sum()), self_ident) + SelfKind::Explicit(self.parse_ty_sum()?, self_ident) } else { SelfKind::Value(self_ident) } @@ -4750,11 +4750,11 @@ impl<'a> Parser<'a> { }; - try!(self.expect(&token::CloseDelim(token::Paren))); + self.expect(&token::CloseDelim(token::Paren))?; let hi = self.span.hi; - let ret_ty = try!(self.parse_ret_ty()); + let ret_ty = self.parse_ret_ty()?; let fn_decl = P(FnDecl { inputs: fn_inputs, @@ -4771,8 +4771,8 @@ impl<'a> Parser<'a> { if self.eat(&token::OrOr) { Vec::new() } else { - try!(self.expect(&token::BinOp(token::Or))); - try!(self.parse_obsolete_closure_kind()); + self.expect(&token::BinOp(token::Or))?; + self.parse_obsolete_closure_kind()?; let args = self.parse_seq_to_before_end( &token::BinOp(token::Or), SeqSep::trailing_allowed(token::Comma), @@ -4782,7 +4782,7 @@ impl<'a> Parser<'a> { args } }; - let output = try!(self.parse_ret_ty()); + let output = self.parse_ret_ty()?; Ok(P(FnDecl { inputs: inputs_captures, @@ -4793,8 +4793,8 @@ impl<'a> Parser<'a> { /// Parse the name and optional generic types of a function header. fn parse_fn_header(&mut self) -> PResult<'a, (Ident, ast::Generics)> { - let id = try!(self.parse_ident()); - let generics = try!(self.parse_generics()); + let id = self.parse_ident()?; + let generics = self.parse_generics()?; Ok((id, generics)) } @@ -4817,10 +4817,10 @@ impl<'a> Parser<'a> { constness: Constness, abi: abi::Abi) -> PResult<'a, ItemInfo> { - let (ident, mut generics) = try!(self.parse_fn_header()); - let decl = try!(self.parse_fn_decl(false)); - generics.where_clause = try!(self.parse_where_clause()); - let (inner_attrs, body) = try!(self.parse_inner_attrs_and_block()); + let (ident, mut generics) = self.parse_fn_header()?; + let decl = self.parse_fn_decl(false)?; + generics.where_clause = self.parse_where_clause()?; + let (inner_attrs, body) = self.parse_inner_attrs_and_block()?; Ok((ident, ItemKind::Fn(decl, unsafety, constness, abi, generics, body), Some(inner_attrs))) } @@ -4842,18 +4842,18 @@ impl<'a> Parser<'a> { pub fn parse_fn_front_matter(&mut self) -> PResult<'a, (ast::Constness, ast::Unsafety, abi::Abi)> { let is_const_fn = self.eat_keyword(keywords::Const); - let unsafety = try!(self.parse_unsafety()); + let unsafety = self.parse_unsafety()?; let (constness, unsafety, abi) = if is_const_fn { (Constness::Const, unsafety, Abi::Rust) } else { let abi = if self.eat_keyword(keywords::Extern) { - try!(self.parse_opt_abi()).unwrap_or(Abi::C) + self.parse_opt_abi()?.unwrap_or(Abi::C) } else { Abi::Rust }; (Constness::NotConst, unsafety, abi) }; - try!(self.expect_keyword(keywords::Fn)); + self.expect_keyword(keywords::Fn)?; Ok((constness, unsafety, abi)) } @@ -4861,27 +4861,27 @@ impl<'a> Parser<'a> { pub fn parse_impl_item(&mut self) -> PResult<'a, ImplItem> { maybe_whole!(no_clone_from_p self, NtImplItem); - let mut attrs = try!(self.parse_outer_attributes()); + let mut attrs = self.parse_outer_attributes()?; let lo = self.span.lo; - let vis = try!(self.parse_visibility()); - let defaultness = try!(self.parse_defaultness()); + let vis = self.parse_visibility()?; + let defaultness = self.parse_defaultness()?; let (name, node) = if self.eat_keyword(keywords::Type) { - let name = try!(self.parse_ident()); - try!(self.expect(&token::Eq)); - let typ = try!(self.parse_ty_sum()); - try!(self.expect(&token::Semi)); + let name = self.parse_ident()?; + self.expect(&token::Eq)?; + let typ = self.parse_ty_sum()?; + self.expect(&token::Semi)?; (name, ast::ImplItemKind::Type(typ)) } else if self.is_const_item() { - try!(self.expect_keyword(keywords::Const)); - let name = try!(self.parse_ident()); - try!(self.expect(&token::Colon)); - let typ = try!(self.parse_ty_sum()); - try!(self.expect(&token::Eq)); - let expr = try!(self.parse_expr()); - try!(self.commit_expr_expecting(&expr, token::Semi)); + self.expect_keyword(keywords::Const)?; + let name = self.parse_ident()?; + self.expect(&token::Colon)?; + let typ = self.parse_ty_sum()?; + self.expect(&token::Eq)?; + let expr = self.parse_expr()?; + self.commit_expr_expecting(&expr, token::Semi)?; (name, ast::ImplItemKind::Const(typ, expr)) } else { - let (name, inner_attrs, node) = try!(self.parse_impl_method(vis)); + let (name, inner_attrs, node) = self.parse_impl_method(vis)?; attrs.extend(inner_attrs); (name, node) }; @@ -4935,31 +4935,31 @@ impl<'a> Parser<'a> { self.complain_if_pub_macro(vis, last_span); let lo = self.span.lo; - let pth = try!(self.parse_path(NoTypesAllowed)); - try!(self.expect(&token::Not)); + let pth = self.parse_path(NoTypesAllowed)?; + self.expect(&token::Not)?; // eat a matched-delimiter token tree: - let delim = try!(self.expect_open_delim()); - let tts = try!(self.parse_seq_to_end(&token::CloseDelim(delim), + let delim = self.expect_open_delim()?; + let tts = self.parse_seq_to_end(&token::CloseDelim(delim), SeqSep::none(), - |p| p.parse_token_tree())); + |p| p.parse_token_tree())?; let m_ = Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT }; let m: ast::Mac = codemap::Spanned { node: m_, span: mk_sp(lo, self.last_span.hi) }; if delim != token::Brace { - try!(self.expect(&token::Semi)) + self.expect(&token::Semi)? } Ok((token::special_idents::invalid, vec![], ast::ImplItemKind::Macro(m))) } else { - let (constness, unsafety, abi) = try!(self.parse_fn_front_matter()); - let ident = try!(self.parse_ident()); - let mut generics = try!(self.parse_generics()); - let (explicit_self, decl) = try!(self.parse_fn_decl_with_self(|p| { + let (constness, unsafety, abi) = self.parse_fn_front_matter()?; + let ident = self.parse_ident()?; + let mut generics = self.parse_generics()?; + let (explicit_self, decl) = self.parse_fn_decl_with_self(|p| { p.parse_arg() - })); - generics.where_clause = try!(self.parse_where_clause()); - let (inner_attrs, body) = try!(self.parse_inner_attrs_and_block()); + })?; + generics.where_clause = self.parse_where_clause()?; + let (inner_attrs, body) = self.parse_inner_attrs_and_block()?; Ok((ident, inner_attrs, ast::ImplItemKind::Method(ast::MethodSig { generics: generics, abi: abi, @@ -4974,15 +4974,15 @@ impl<'a> Parser<'a> { /// Parse trait Foo { ... } fn parse_item_trait(&mut self, unsafety: Unsafety) -> PResult<'a, ItemInfo> { - let ident = try!(self.parse_ident()); - let mut tps = try!(self.parse_generics()); + let ident = self.parse_ident()?; + let mut tps = self.parse_generics()?; // Parse supertrait bounds. - let bounds = try!(self.parse_colon_then_ty_param_bounds(BoundParsingMode::Bare)); + let bounds = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Bare)?; - tps.where_clause = try!(self.parse_where_clause()); + tps.where_clause = self.parse_where_clause()?; - let meths = try!(self.parse_trait_items()); + let meths = self.parse_trait_items()?; Ok((ident, ItemKind::Trait(unsafety, tps, bounds, meths), None)) } @@ -4994,7 +4994,7 @@ impl<'a> Parser<'a> { let impl_span = self.span; // First, parse type parameters if necessary. - let mut generics = try!(self.parse_generics()); + let mut generics = self.parse_generics()?; // Special case: if the next identifier that follows is '(', don't // allow this to be parsed as a trait. @@ -5008,7 +5008,7 @@ impl<'a> Parser<'a> { }; // Parse the trait. - let mut ty = try!(self.parse_ty_sum()); + let mut ty = self.parse_ty_sum()?; // Parse traits, if necessary. let opt_trait = if could_be_trait && self.eat_keyword(keywords::For) { @@ -5043,22 +5043,22 @@ impl<'a> Parser<'a> { allowed to have generics"); } - try!(self.expect(&token::OpenDelim(token::Brace))); - try!(self.expect(&token::CloseDelim(token::Brace))); + self.expect(&token::OpenDelim(token::Brace))?; + self.expect(&token::CloseDelim(token::Brace))?; Ok((ast_util::impl_pretty_name(&opt_trait, None), ItemKind::DefaultImpl(unsafety, opt_trait.unwrap()), None)) } else { if opt_trait.is_some() { - ty = try!(self.parse_ty_sum()); + ty = self.parse_ty_sum()?; } - generics.where_clause = try!(self.parse_where_clause()); + generics.where_clause = self.parse_where_clause()?; - try!(self.expect(&token::OpenDelim(token::Brace))); - let attrs = try!(self.parse_inner_attributes()); + self.expect(&token::OpenDelim(token::Brace))?; + let attrs = self.parse_inner_attributes()?; let mut impl_items = vec![]; while !self.eat(&token::CloseDelim(token::Brace)) { - impl_items.push(try!(self.parse_impl_item())); + impl_items.push(self.parse_impl_item()?); } Ok((ast_util::impl_pretty_name(&opt_trait, Some(&ty)), @@ -5070,16 +5070,16 @@ impl<'a> Parser<'a> { /// Parse a::B<String,i32> fn parse_trait_ref(&mut self) -> PResult<'a, TraitRef> { Ok(ast::TraitRef { - path: try!(self.parse_path(LifetimeAndTypesWithoutColons)), + path: self.parse_path(LifetimeAndTypesWithoutColons)?, ref_id: ast::DUMMY_NODE_ID, }) } fn parse_late_bound_lifetime_defs(&mut self) -> PResult<'a, Vec<ast::LifetimeDef>> { if self.eat_keyword(keywords::For) { - try!(self.expect(&token::Lt)); - let lifetime_defs = try!(self.parse_lifetime_defs()); - try!(self.expect_gt()); + self.expect(&token::Lt)?; + let lifetime_defs = self.parse_lifetime_defs()?; + self.expect_gt()?; Ok(lifetime_defs) } else { Ok(Vec::new()) @@ -5089,19 +5089,19 @@ impl<'a> Parser<'a> { /// Parse for<'l> a::B<String,i32> fn parse_poly_trait_ref(&mut self) -> PResult<'a, PolyTraitRef> { let lo = self.span.lo; - let lifetime_defs = try!(self.parse_late_bound_lifetime_defs()); + let lifetime_defs = self.parse_late_bound_lifetime_defs()?; Ok(ast::PolyTraitRef { bound_lifetimes: lifetime_defs, - trait_ref: try!(self.parse_trait_ref()), + trait_ref: self.parse_trait_ref()?, span: mk_sp(lo, self.last_span.hi), }) } /// Parse struct Foo { ... } fn parse_item_struct(&mut self) -> PResult<'a, ItemInfo> { - let class_name = try!(self.parse_ident()); - let mut generics = try!(self.parse_generics()); + let class_name = self.parse_ident()?; + let mut generics = self.parse_generics()?; // There is a special case worth noting here, as reported in issue #17904. // If we are parsing a tuple struct it is the case that the where clause @@ -5118,25 +5118,25 @@ impl<'a> Parser<'a> { // struct. let vdata = if self.token.is_keyword(keywords::Where) { - generics.where_clause = try!(self.parse_where_clause()); + generics.where_clause = self.parse_where_clause()?; if self.eat(&token::Semi) { // If we see a: `struct Foo<T> where T: Copy;` style decl. VariantData::Unit(ast::DUMMY_NODE_ID) } else { // If we see: `struct Foo<T> where T: Copy { ... }` - VariantData::Struct(try!(self.parse_record_struct_body()), ast::DUMMY_NODE_ID) + VariantData::Struct(self.parse_record_struct_body()?, ast::DUMMY_NODE_ID) } // No `where` so: `struct Foo<T>;` } else if self.eat(&token::Semi) { VariantData::Unit(ast::DUMMY_NODE_ID) // Record-style struct definition } else if self.token == token::OpenDelim(token::Brace) { - VariantData::Struct(try!(self.parse_record_struct_body()), ast::DUMMY_NODE_ID) + VariantData::Struct(self.parse_record_struct_body()?, ast::DUMMY_NODE_ID) // Tuple-style struct definition with optional where-clause. } else if self.token == token::OpenDelim(token::Paren) { - let body = VariantData::Tuple(try!(self.parse_tuple_struct_body()), ast::DUMMY_NODE_ID); - generics.where_clause = try!(self.parse_where_clause()); - try!(self.expect(&token::Semi)); + let body = VariantData::Tuple(self.parse_tuple_struct_body()?, ast::DUMMY_NODE_ID); + generics.where_clause = self.parse_where_clause()?; + self.expect(&token::Semi)?; body } else { let token_str = self.this_token_to_string(); @@ -5151,7 +5151,7 @@ impl<'a> Parser<'a> { let mut fields = Vec::new(); if self.eat(&token::OpenDelim(token::Brace)) { while self.token != token::CloseDelim(token::Brace) { - fields.push(try!(self.parse_struct_decl_field())); + fields.push(self.parse_struct_decl_field()?); } self.bump(); @@ -5168,21 +5168,21 @@ impl<'a> Parser<'a> { pub fn parse_tuple_struct_body(&mut self) -> PResult<'a, Vec<StructField>> { // This is the case where we find `struct Foo<T>(T) where T: Copy;` // Unit like structs are handled in parse_item_struct function - let fields = try!(self.parse_unspanned_seq( + let fields = self.parse_unspanned_seq( &token::OpenDelim(token::Paren), &token::CloseDelim(token::Paren), SeqSep::trailing_allowed(token::Comma), |p| { - let attrs = try!(p.parse_outer_attributes()); + let attrs = p.parse_outer_attributes()?; let lo = p.span.lo; let struct_field_ = ast::StructField_ { - kind: UnnamedField(try!(p.parse_visibility())), + kind: UnnamedField(p.parse_visibility()?), id: ast::DUMMY_NODE_ID, - ty: try!(p.parse_ty_sum()), + ty: p.parse_ty_sum()?, attrs: attrs, }; Ok(spanned(lo, p.span.hi, struct_field_)) - })); + })?; Ok(fields) } @@ -5192,7 +5192,7 @@ impl<'a> Parser<'a> { vis: Visibility, attrs: Vec<Attribute> ) -> PResult<'a, StructField> { - let a_var = try!(self.parse_name_and_ty(vis, attrs)); + let a_var = self.parse_name_and_ty(vis, attrs)?; match self.token { token::Comma => { self.bump(); @@ -5213,7 +5213,7 @@ impl<'a> Parser<'a> { /// Parse an element of a struct definition fn parse_struct_decl_field(&mut self) -> PResult<'a, StructField> { - let attrs = try!(self.parse_outer_attributes()); + let attrs = self.parse_outer_attributes()?; if self.eat_keyword(keywords::Pub) { return self.parse_single_struct_field(Visibility::Public, attrs); @@ -5240,7 +5240,7 @@ impl<'a> Parser<'a> { /// Given a termination token, parse all of the items in a module fn parse_mod_items(&mut self, term: &token::Token, inner_lo: BytePos) -> PResult<'a, Mod> { let mut items = vec![]; - while let Some(item) = try!(self.parse_item()) { + while let Some(item) = self.parse_item()? { items.push(item); } @@ -5262,12 +5262,12 @@ impl<'a> Parser<'a> { } fn parse_item_const(&mut self, m: Option<Mutability>) -> PResult<'a, ItemInfo> { - let id = try!(self.parse_ident()); - try!(self.expect(&token::Colon)); - let ty = try!(self.parse_ty_sum()); - try!(self.expect(&token::Eq)); - let e = try!(self.parse_expr()); - try!(self.commit_expr_expecting(&e, token::Semi)); + let id = self.parse_ident()?; + self.expect(&token::Colon)?; + let ty = self.parse_ty_sum()?; + self.expect(&token::Eq)?; + let e = self.parse_expr()?; + self.commit_expr_expecting(&e, token::Semi)?; let item = match m { Some(m) => ItemKind::Static(ty, m, e), None => ItemKind::Const(ty, e), @@ -5278,18 +5278,18 @@ impl<'a> Parser<'a> { /// Parse a `mod <foo> { ... }` or `mod <foo>;` item fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> PResult<'a, ItemInfo> { let id_span = self.span; - let id = try!(self.parse_ident()); + let id = self.parse_ident()?; if self.check(&token::Semi) { self.bump(); // This mod is in an external file. Let's go get it! - let (m, attrs) = try!(self.eval_src_mod(id, outer_attrs, id_span)); + let (m, attrs) = self.eval_src_mod(id, outer_attrs, id_span)?; Ok((id, m, Some(attrs))) } else { self.push_mod_path(id, outer_attrs); - try!(self.expect(&token::OpenDelim(token::Brace))); + self.expect(&token::OpenDelim(token::Brace))?; let mod_inner_lo = self.span.lo; - let attrs = try!(self.parse_inner_attributes()); - let m = try!(self.parse_mod_items(&token::CloseDelim(token::Brace), mod_inner_lo)); + let attrs = self.parse_inner_attributes()?; + let m = self.parse_mod_items(&token::CloseDelim(token::Brace), mod_inner_lo)?; self.pop_mod_path(); Ok((id, ItemKind::Mod(m), Some(attrs))) } @@ -5408,9 +5408,9 @@ impl<'a> Parser<'a> { outer_attrs: &[ast::Attribute], id_sp: Span) -> PResult<'a, (ast::ItemKind, Vec<ast::Attribute> )> { - let ModulePathSuccess { path, owns_directory } = try!(self.submod_path(id, + let ModulePathSuccess { path, owns_directory } = self.submod_path(id, outer_attrs, - id_sp)); + id_sp)?; self.eval_src_mod_from_path(path, owns_directory, @@ -5447,8 +5447,8 @@ impl<'a> Parser<'a> { Some(name), id_sp); let mod_inner_lo = p0.span.lo; - let mod_attrs = try!(p0.parse_inner_attributes()); - let m0 = try!(p0.parse_mod_items(&token::Eof, mod_inner_lo)); + let mod_attrs = p0.parse_inner_attributes()?; + let m0 = p0.parse_mod_items(&token::Eof, mod_inner_lo)?; self.sess.included_mod_stack.borrow_mut().pop(); Ok((ast::ItemKind::Mod(m0), mod_attrs)) } @@ -5456,13 +5456,13 @@ impl<'a> Parser<'a> { /// Parse a function declaration from a foreign module fn parse_item_foreign_fn(&mut self, vis: ast::Visibility, lo: BytePos, attrs: Vec<Attribute>) -> PResult<'a, ForeignItem> { - try!(self.expect_keyword(keywords::Fn)); + self.expect_keyword(keywords::Fn)?; - let (ident, mut generics) = try!(self.parse_fn_header()); - let decl = try!(self.parse_fn_decl(true)); - generics.where_clause = try!(self.parse_where_clause()); + let (ident, mut generics) = self.parse_fn_header()?; + let decl = self.parse_fn_decl(true)?; + generics.where_clause = self.parse_where_clause()?; let hi = self.span.hi; - try!(self.expect(&token::Semi)); + self.expect(&token::Semi)?; Ok(ast::ForeignItem { ident: ident, attrs: attrs, @@ -5476,14 +5476,14 @@ impl<'a> Parser<'a> { /// Parse a static item from a foreign module fn parse_item_foreign_static(&mut self, vis: ast::Visibility, lo: BytePos, attrs: Vec<Attribute>) -> PResult<'a, ForeignItem> { - try!(self.expect_keyword(keywords::Static)); + self.expect_keyword(keywords::Static)?; let mutbl = self.eat_keyword(keywords::Mut); - let ident = try!(self.parse_ident()); - try!(self.expect(&token::Colon)); - let ty = try!(self.parse_ty_sum()); + let ident = self.parse_ident()?; + self.expect(&token::Colon)?; + let ty = self.parse_ty_sum()?; let hi = self.span.hi; - try!(self.expect(&token::Semi)); + self.expect(&token::Semi)?; Ok(ForeignItem { ident: ident, attrs: attrs, @@ -5506,13 +5506,13 @@ impl<'a> Parser<'a> { attrs: Vec<Attribute>) -> PResult<'a, P<Item>> { - let crate_name = try!(self.parse_ident()); - let (maybe_path, ident) = if let Some(ident) = try!(self.parse_rename()) { + let crate_name = self.parse_ident()?; + let (maybe_path, ident) = if let Some(ident) = self.parse_rename()? { (Some(crate_name.name), ident) } else { (None, crate_name) }; - try!(self.expect(&token::Semi)); + self.expect(&token::Semi)?; let last_span = self.last_span; Ok(self.mk_item(lo, @@ -5539,17 +5539,17 @@ impl<'a> Parser<'a> { visibility: Visibility, mut attrs: Vec<Attribute>) -> PResult<'a, P<Item>> { - try!(self.expect(&token::OpenDelim(token::Brace))); + self.expect(&token::OpenDelim(token::Brace))?; let abi = opt_abi.unwrap_or(Abi::C); - attrs.extend(try!(self.parse_inner_attributes())); + attrs.extend(self.parse_inner_attributes()?); let mut foreign_items = vec![]; - while let Some(item) = try!(self.parse_foreign_item()) { + while let Some(item) = self.parse_foreign_item()? { foreign_items.push(item); } - try!(self.expect(&token::CloseDelim(token::Brace))); + self.expect(&token::CloseDelim(token::Brace))?; let last_span = self.last_span; let m = ast::ForeignMod { @@ -5566,12 +5566,12 @@ impl<'a> Parser<'a> { /// Parse type Foo = Bar; fn parse_item_type(&mut self) -> PResult<'a, ItemInfo> { - let ident = try!(self.parse_ident()); - let mut tps = try!(self.parse_generics()); - tps.where_clause = try!(self.parse_where_clause()); - try!(self.expect(&token::Eq)); - let ty = try!(self.parse_ty_sum()); - try!(self.expect(&token::Semi)); + let ident = self.parse_ident()?; + let mut tps = self.parse_generics()?; + tps.where_clause = self.parse_where_clause()?; + self.expect(&token::Eq)?; + let ty = self.parse_ty_sum()?; + self.expect(&token::Semi)?; Ok((ident, ItemKind::Ty(ty, tps), None)) } @@ -5581,23 +5581,23 @@ impl<'a> Parser<'a> { let mut all_nullary = true; let mut any_disr = None; while self.token != token::CloseDelim(token::Brace) { - let variant_attrs = try!(self.parse_outer_attributes()); + let variant_attrs = self.parse_outer_attributes()?; let vlo = self.span.lo; let struct_def; let mut disr_expr = None; - let ident = try!(self.parse_ident()); + let ident = self.parse_ident()?; if self.check(&token::OpenDelim(token::Brace)) { // Parse a struct variant. all_nullary = false; - struct_def = VariantData::Struct(try!(self.parse_record_struct_body()), + struct_def = VariantData::Struct(self.parse_record_struct_body()?, ast::DUMMY_NODE_ID); } else if self.check(&token::OpenDelim(token::Paren)) { all_nullary = false; - struct_def = VariantData::Tuple(try!(self.parse_tuple_struct_body()), + struct_def = VariantData::Tuple(self.parse_tuple_struct_body()?, ast::DUMMY_NODE_ID); } else if self.eat(&token::Eq) { - disr_expr = Some(try!(self.parse_expr())); + disr_expr = Some(self.parse_expr()?); any_disr = disr_expr.as_ref().map(|expr| expr.span); struct_def = VariantData::Unit(ast::DUMMY_NODE_ID); } else { @@ -5614,7 +5614,7 @@ impl<'a> Parser<'a> { if !self.eat(&token::Comma) { break; } } - try!(self.expect(&token::CloseDelim(token::Brace))); + self.expect(&token::CloseDelim(token::Brace))?; match any_disr { Some(disr_span) if !all_nullary => self.span_err(disr_span, @@ -5627,12 +5627,12 @@ impl<'a> Parser<'a> { /// Parse an "enum" declaration fn parse_item_enum(&mut self) -> PResult<'a, ItemInfo> { - let id = try!(self.parse_ident()); - let mut generics = try!(self.parse_generics()); - generics.where_clause = try!(self.parse_where_clause()); - try!(self.expect(&token::OpenDelim(token::Brace))); + let id = self.parse_ident()?; + let mut generics = self.parse_generics()?; + generics.where_clause = self.parse_where_clause()?; + self.expect(&token::OpenDelim(token::Brace))?; - let enum_definition = try!(self.parse_enum_def(&generics)); + let enum_definition = self.parse_enum_def(&generics)?; Ok((id, ItemKind::Enum(enum_definition, generics), None)) } @@ -5687,12 +5687,12 @@ impl<'a> Parser<'a> { let lo = self.span.lo; - let visibility = try!(self.parse_visibility()); + let visibility = self.parse_visibility()?; if self.eat_keyword(keywords::Use) { // USE ITEM - let item_ = ItemKind::Use(try!(self.parse_view_path())); - try!(self.expect(&token::Semi)); + let item_ = ItemKind::Use(self.parse_view_path()?); + self.expect(&token::Semi)?; let last_span = self.last_span; let item = self.mk_item(lo, @@ -5706,16 +5706,16 @@ impl<'a> Parser<'a> { if self.eat_keyword(keywords::Extern) { if self.eat_keyword(keywords::Crate) { - return Ok(Some(try!(self.parse_item_extern_crate(lo, visibility, attrs)))); + return Ok(Some(self.parse_item_extern_crate(lo, visibility, attrs)?)); } - let opt_abi = try!(self.parse_opt_abi()); + let opt_abi = self.parse_opt_abi()?; if self.eat_keyword(keywords::Fn) { // EXTERN FUNCTION ITEM let abi = opt_abi.unwrap_or(Abi::C); let (ident, item_, extra_attrs) = - try!(self.parse_item_fn(Unsafety::Normal, Constness::NotConst, abi)); + self.parse_item_fn(Unsafety::Normal, Constness::NotConst, abi)?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5725,10 +5725,10 @@ impl<'a> Parser<'a> { maybe_append(attrs, extra_attrs)); return Ok(Some(item)); } else if self.check(&token::OpenDelim(token::Brace)) { - return Ok(Some(try!(self.parse_item_foreign_mod(lo, opt_abi, visibility, attrs)))); + return Ok(Some(self.parse_item_foreign_mod(lo, opt_abi, visibility, attrs)?)); } - try!(self.unexpected()); + self.unexpected()?; } if self.eat_keyword(keywords::Static) { @@ -5738,7 +5738,7 @@ impl<'a> Parser<'a> { } else { Mutability::Immutable }; - let (ident, item_, extra_attrs) = try!(self.parse_item_const(Some(m))); + let (ident, item_, extra_attrs) = self.parse_item_const(Some(m))?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5760,7 +5760,7 @@ impl<'a> Parser<'a> { }; self.bump(); let (ident, item_, extra_attrs) = - try!(self.parse_item_fn(unsafety, Constness::Const, Abi::Rust)); + self.parse_item_fn(unsafety, Constness::Const, Abi::Rust)?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5778,7 +5778,7 @@ impl<'a> Parser<'a> { .fileline_help(last_span, "did you mean to declare a static?") .emit(); } - let (ident, item_, extra_attrs) = try!(self.parse_item_const(None)); + let (ident, item_, extra_attrs) = self.parse_item_const(None)?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5792,10 +5792,10 @@ impl<'a> Parser<'a> { self.look_ahead(1, |t| t.is_keyword(keywords::Trait)) { // UNSAFE TRAIT ITEM - try!(self.expect_keyword(keywords::Unsafe)); - try!(self.expect_keyword(keywords::Trait)); + self.expect_keyword(keywords::Unsafe)?; + self.expect_keyword(keywords::Trait)?; let (ident, item_, extra_attrs) = - try!(self.parse_item_trait(ast::Unsafety::Unsafe)); + self.parse_item_trait(ast::Unsafety::Unsafe)?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5809,9 +5809,9 @@ impl<'a> Parser<'a> { self.look_ahead(1, |t| t.is_keyword(keywords::Impl)) { // IMPL ITEM - try!(self.expect_keyword(keywords::Unsafe)); - try!(self.expect_keyword(keywords::Impl)); - let (ident, item_, extra_attrs) = try!(self.parse_item_impl(ast::Unsafety::Unsafe)); + self.expect_keyword(keywords::Unsafe)?; + self.expect_keyword(keywords::Impl)?; + let (ident, item_, extra_attrs) = self.parse_item_impl(ast::Unsafety::Unsafe)?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5825,7 +5825,7 @@ impl<'a> Parser<'a> { // FUNCTION ITEM self.bump(); let (ident, item_, extra_attrs) = - try!(self.parse_item_fn(Unsafety::Normal, Constness::NotConst, Abi::Rust)); + self.parse_item_fn(Unsafety::Normal, Constness::NotConst, Abi::Rust)?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5840,13 +5840,13 @@ impl<'a> Parser<'a> { // UNSAFE FUNCTION ITEM self.bump(); let abi = if self.eat_keyword(keywords::Extern) { - try!(self.parse_opt_abi()).unwrap_or(Abi::C) + self.parse_opt_abi()?.unwrap_or(Abi::C) } else { Abi::Rust }; - try!(self.expect_keyword(keywords::Fn)); + self.expect_keyword(keywords::Fn)?; let (ident, item_, extra_attrs) = - try!(self.parse_item_fn(Unsafety::Unsafe, Constness::NotConst, abi)); + self.parse_item_fn(Unsafety::Unsafe, Constness::NotConst, abi)?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5859,7 +5859,7 @@ impl<'a> Parser<'a> { if self.eat_keyword(keywords::Mod) { // MODULE ITEM let (ident, item_, extra_attrs) = - try!(self.parse_item_mod(&attrs[..])); + self.parse_item_mod(&attrs[..])?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5871,7 +5871,7 @@ impl<'a> Parser<'a> { } if self.eat_keyword(keywords::Type) { // TYPE ITEM - let (ident, item_, extra_attrs) = try!(self.parse_item_type()); + let (ident, item_, extra_attrs) = self.parse_item_type()?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5883,7 +5883,7 @@ impl<'a> Parser<'a> { } if self.eat_keyword(keywords::Enum) { // ENUM ITEM - let (ident, item_, extra_attrs) = try!(self.parse_item_enum()); + let (ident, item_, extra_attrs) = self.parse_item_enum()?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5896,7 +5896,7 @@ impl<'a> Parser<'a> { if self.eat_keyword(keywords::Trait) { // TRAIT ITEM let (ident, item_, extra_attrs) = - try!(self.parse_item_trait(ast::Unsafety::Normal)); + self.parse_item_trait(ast::Unsafety::Normal)?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5908,7 +5908,7 @@ impl<'a> Parser<'a> { } if self.eat_keyword(keywords::Impl) { // IMPL ITEM - let (ident, item_, extra_attrs) = try!(self.parse_item_impl(ast::Unsafety::Normal)); + let (ident, item_, extra_attrs) = self.parse_item_impl(ast::Unsafety::Normal)?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5920,7 +5920,7 @@ impl<'a> Parser<'a> { } if self.eat_keyword(keywords::Struct) { // STRUCT ITEM - let (ident, item_, extra_attrs) = try!(self.parse_item_struct()); + let (ident, item_, extra_attrs) = self.parse_item_struct()?; let last_span = self.last_span; let item = self.mk_item(lo, last_span.hi, @@ -5935,21 +5935,21 @@ impl<'a> Parser<'a> { /// Parse a foreign item. fn parse_foreign_item(&mut self) -> PResult<'a, Option<ForeignItem>> { - let attrs = try!(self.parse_outer_attributes()); + let attrs = self.parse_outer_attributes()?; let lo = self.span.lo; - let visibility = try!(self.parse_visibility()); + let visibility = self.parse_visibility()?; if self.check_keyword(keywords::Static) { // FOREIGN STATIC ITEM - return Ok(Some(try!(self.parse_item_foreign_static(visibility, lo, attrs)))); + return Ok(Some(self.parse_item_foreign_static(visibility, lo, attrs)?)); } if self.check_keyword(keywords::Fn) || self.check_keyword(keywords::Unsafe) { // FOREIGN FUNCTION ITEM - return Ok(Some(try!(self.parse_item_foreign_fn(visibility, lo, attrs)))); + return Ok(Some(self.parse_item_foreign_fn(visibility, lo, attrs)?)); } // FIXME #5668: this will occur for a macro invocation: - match try!(self.parse_macro_use_or_failure(attrs, true, false, lo, visibility)) { + match self.parse_macro_use_or_failure(attrs, true, false, lo, visibility)? { Some(item) => { return Err(self.span_fatal(item.span, "macros cannot expand to foreign items")); } @@ -5979,22 +5979,22 @@ impl<'a> Parser<'a> { let mac_lo = self.span.lo; // item macro. - let pth = try!(self.parse_path(NoTypesAllowed)); - try!(self.expect(&token::Not)); + let pth = self.parse_path(NoTypesAllowed)?; + self.expect(&token::Not)?; // a 'special' identifier (like what `macro_rules!` uses) // is optional. We should eventually unify invoc syntax // and remove this. let id = if self.token.is_plain_ident() { - try!(self.parse_ident()) + self.parse_ident()? } else { token::special_idents::invalid // no special identifier }; // eat a matched-delimiter token tree: - let delim = try!(self.expect_open_delim()); - let tts = try!(self.parse_seq_to_end(&token::CloseDelim(delim), + let delim = self.expect_open_delim()?; + let tts = self.parse_seq_to_end(&token::CloseDelim(delim), SeqSep::none(), - |p| p.parse_token_tree())); + |p| p.parse_token_tree())?; // single-variant-enum... : let m = Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT }; let m: ast::Mac = codemap::Spanned { node: m, @@ -6038,7 +6038,7 @@ impl<'a> Parser<'a> { } pub fn parse_item(&mut self) -> PResult<'a, Option<P<Item>>> { - let attrs = try!(self.parse_outer_attributes()); + let attrs = self.parse_outer_attributes()?; self.parse_item_(attrs, true, false) } @@ -6057,11 +6057,11 @@ impl<'a> Parser<'a> { if self.check(&token::OpenDelim(token::Brace)) { // use {foo,bar} - let idents = try!(self.parse_unspanned_seq( + let idents = self.parse_unspanned_seq( &token::OpenDelim(token::Brace), &token::CloseDelim(token::Brace), SeqSep::trailing_allowed(token::Comma), - |p| p.parse_path_list_item())); + |p| p.parse_path_list_item())?; let path = ast::Path { span: mk_sp(lo, self.span.hi), global: false, @@ -6070,7 +6070,7 @@ impl<'a> Parser<'a> { return Ok(P(spanned(lo, self.span.hi, ViewPathList(path, idents)))); } - let first_ident = try!(self.parse_ident()); + let first_ident = self.parse_ident()?; let mut path = vec!(first_ident); if let token::ModSep = self.token { // foo::bar or foo::{a,b,c} or foo::* @@ -6079,18 +6079,18 @@ impl<'a> Parser<'a> { match self.token { token::Ident(..) => { - let ident = try!(self.parse_ident()); + let ident = self.parse_ident()?; path.push(ident); } // foo::bar::{a,b,c} token::OpenDelim(token::Brace) => { - let idents = try!(self.parse_unspanned_seq( + let idents = self.parse_unspanned_seq( &token::OpenDelim(token::Brace), &token::CloseDelim(token::Brace), SeqSep::trailing_allowed(token::Comma), |p| p.parse_path_list_item() - )); + )?; let path = ast::Path { span: mk_sp(lo, self.span.hi), global: false, @@ -6140,7 +6140,7 @@ impl<'a> Parser<'a> { } }).collect() }; - rename_to = try!(self.parse_rename()).unwrap_or(rename_to); + rename_to = self.parse_rename()?.unwrap_or(rename_to); Ok(P(spanned(lo, self.last_span.hi, ViewPathSimple(rename_to, path)))) } @@ -6157,8 +6157,8 @@ impl<'a> Parser<'a> { pub fn parse_crate_mod(&mut self) -> PResult<'a, Crate> { let lo = self.span.lo; Ok(ast::Crate { - attrs: try!(self.parse_inner_attributes()), - module: try!(self.parse_mod_items(&token::Eof, lo)), + attrs: self.parse_inner_attributes()?, + module: self.parse_mod_items(&token::Eof, lo)?, config: self.cfg.clone(), span: mk_sp(lo, self.span.lo), exported_macros: Vec::new(), diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 033ac9440bc..a02a10aa003 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -706,7 +706,7 @@ impl<'a> PartialEq<InternedString> for &'a str { impl Decodable for InternedString { fn decode<D: Decoder>(d: &mut D) -> Result<InternedString, D::Error> { - Ok(intern(try!(d.read_str()).as_ref()).as_str()) + Ok(intern(d.read_str()?.as_ref()).as_str()) } } |