diff --git a/src/lib/exec.rs b/src/lib/exec.rs index 5742b3f56e..0a6a836ae0 100644 --- a/src/lib/exec.rs +++ b/src/lib/exec.rs @@ -135,32 +135,32 @@ impl Executor for Interpreter { Ok(result) } ExprDef::IfExpr(ref cond, ref expr, None) => { - Ok(if r#try!(self.run(cond)).borrow().is_true() { - r#try!(self.run(expr)) + Ok(if self.run(cond)?.borrow().is_true() { + self.run(expr)? } else { Gc::new(ValueData::Undefined) }) } ExprDef::IfExpr(ref cond, ref expr, Some(ref else_e)) => { - Ok(if r#try!(self.run(cond)).borrow().is_true() { - r#try!(self.run(expr)) + Ok(if self.run(cond)?.borrow().is_true() { + self.run(expr)? } else { - r#try!(self.run(else_e)) + self.run(else_e)? }) } ExprDef::SwitchExpr(ref val_e, ref vals, ref default) => { - let val = r#try!(self.run(val_e)).clone(); + let val = self.run(val_e)?.clone(); let mut result = Gc::new(ValueData::Null); let mut matched = false; for tup in vals.iter() { let tup: &(Expr, Vec) = tup; let cond = &tup.0; let block = &tup.1; - if val == r#try!(self.run(cond)) { + if val == self.run(cond)? { matched = true; let last_expr = block.last().unwrap(); for expr in block.iter() { - let e_result = r#try!(self.run(expr)); + let e_result = self.run(expr)?; if expr == last_expr { result = e_result; } @@ -168,7 +168,7 @@ impl Executor for Interpreter { } } if !matched && default.is_some() { - result = r#try!(self.run(default.as_ref().unwrap())); + result = self.run(default.as_ref().unwrap())?; } Ok(result) } @@ -217,8 +217,8 @@ impl Executor for Interpreter { Ok(Gc::new(ValueData::Function(GcCell::new(function)))) } ExprDef::BinOpExpr(BinOp::Num(ref op), ref a, ref b) => { - let v_r_a = r#try!(self.run(a)); - let v_r_b = r#try!(self.run(b)); + let v_r_a = self.run(a)?; + let v_r_b = self.run(b)?; let v_a = (*v_r_a).clone(); let v_b = (*v_r_b).clone(); Ok(Gc::new(match *op { @@ -230,7 +230,7 @@ impl Executor for Interpreter { })) } ExprDef::UnaryOpExpr(ref op, ref a) => { - let v_r_a = r#try!(self.run(a)); + let v_r_a = self.run(a)?; let v_a = (*v_r_a).clone(); Ok(match *op { UnaryOp::Minus => to_value(-v_a.to_num()), @@ -240,8 +240,8 @@ impl Executor for Interpreter { }) } ExprDef::BinOpExpr(BinOp::Bit(ref op), ref a, ref b) => { - let v_r_a = r#try!(self.run(a)); - let v_r_b = r#try!(self.run(b)); + let v_r_a = self.run(a)?; + let v_r_b = self.run(b)?; let v_a = (*v_r_a).clone(); let v_b = (*v_r_b).clone(); Ok(Gc::new(match *op { @@ -253,8 +253,8 @@ impl Executor for Interpreter { })) } ExprDef::BinOpExpr(BinOp::Comp(ref op), ref a, ref b) => { - let v_r_a = r#try!(self.run(a)); - let v_r_b = r#try!(self.run(b)); + let v_r_a = self.run(a)?; + let v_r_b = self.run(b)?; let v_a = v_r_a.borrow(); let v_b = v_r_b.borrow(); Ok(to_value(match *op { @@ -273,8 +273,8 @@ impl Executor for Interpreter { })) } ExprDef::BinOpExpr(BinOp::Log(ref op), ref a, ref b) => { - let v_a = from_value::(r#try!(self.run(a))).unwrap(); - let v_b = from_value::(r#try!(self.run(b))).unwrap(); + let v_a = from_value::(self.run(a)?).unwrap(); + let v_b = from_value::(self.run(b)?).unwrap(); Ok(match *op { LogOp::And => to_value(v_a && v_b), LogOp::Or => to_value(v_a || v_b), @@ -284,7 +284,7 @@ impl Executor for Interpreter { let func = self.run(callee)?; let mut v_args = Vec::with_capacity(args.len()); for arg in args.iter() { - v_args.push(r#try!(self.run(arg))); + v_args.push(self.run(arg)?); } let this = Gc::new(ValueData::Object( GcCell::new(HashMap::new()), @@ -326,7 +326,7 @@ impl Executor for Interpreter { Some(ref v) => self.run(v), None => Ok(Gc::new(ValueData::Undefined)), }, - ExprDef::ThrowExpr(ref ex) => Err(r#try!(self.run(ex))), + ExprDef::ThrowExpr(ref ex) => Err(self.run(ex)?), ExprDef::AssignExpr(ref ref_e, ref val_e) => { let val = self.run(val_e)?; match ref_e.def { @@ -336,7 +336,7 @@ impl Executor for Interpreter { .initialize_binding(name.clone(), val.clone()); } ExprDef::GetConstFieldExpr(ref obj, ref field) => { - let val_obj = r#try!(self.run(obj)); + let val_obj = self.run(obj)?; val_obj.borrow().set_field(field.clone(), val.clone()); } _ => (), @@ -347,7 +347,7 @@ impl Executor for Interpreter { for var in vars.iter() { let (name, value) = var.clone(); let val = match value { - Some(v) => r#try!(self.run(&v)), + Some(v) => self.run(&v)?, None => Gc::new(ValueData::Null), }; self.environment.create_mutable_binding(name.clone(), false); @@ -359,7 +359,7 @@ impl Executor for Interpreter { for var in vars.iter() { let (name, value) = var.clone(); let val = match value { - Some(v) => r#try!(self.run(&v)), + Some(v) => self.run(&v)?, None => Gc::new(ValueData::Null), }; self.environment.create_mutable_binding(name.clone(), false); @@ -371,7 +371,7 @@ impl Executor for Interpreter { for var in vars.iter() { let (name, value) = var.clone(); let val = match value { - Some(v) => r#try!(self.run(&v)), + Some(v) => self.run(&v)?, None => Gc::new(ValueData::Null), }; self.environment @@ -381,7 +381,7 @@ impl Executor for Interpreter { Ok(Gc::new(ValueData::Undefined)) } ExprDef::TypeOfExpr(ref val_e) => { - let val = r#try!(self.run(val_e)); + let val = self.run(val_e)?; Ok(to_value(match *val { ValueData::Undefined => "undefined", ValueData::Null | ValueData::Object(_, _) => "object", diff --git a/src/lib/js/value.rs b/src/lib/js/value.rs index c703099dbd..177a6decde 100644 --- a/src/lib/js/value.rs +++ b/src/lib/js/value.rs @@ -504,9 +504,9 @@ impl Display for ValueData { match v.borrow().iter().last() { Some((last_key, _)) => { for (key, val) in v.borrow().iter() { - r#try!(write!(f, "{}: {}", key, val.value.clone())); + write!(f, "{}: {}", key, val.value.clone())?; if key != last_key { - r#try!(write!(f, "{}", ", ")); + write!(f, "{}", ", ")?; } } } @@ -517,9 +517,9 @@ impl Display for ValueData { match p.borrow().iter().last() { Some((last_key, _)) => { for (key, val) in p.borrow().iter() { - r#try!(write!(f, "(Private) {}: {}", key, val.value.clone())); + write!(f, "(Private) {}: {}", key, val.value.clone())?; if key != last_key { - r#try!(write!(f, "{}", ", ")); + write!(f, "{}", ", ")?; } } } @@ -747,7 +747,7 @@ impl FromValue for Vec { let len = v.get_field_slice("length").to_int(); let mut vec = Vec::with_capacity(len as usize); for i in 0..len { - vec.push(r#try!(from_value(v.get_field(i.to_string())))) + vec.push(from_value(v.get_field(i.to_string()))?) } Ok(vec) } @@ -812,7 +812,7 @@ impl FromValue for Option { Ok(if value.is_null_or_undefined() { None } else { - Some(r#try!(FromValue::from_value(value))) + Some(FromValue::from_value(value)?) }) } } diff --git a/src/lib/syntax/ast/expr.rs b/src/lib/syntax/ast/expr.rs index de8c63bcd7..06ed1d8822 100644 --- a/src/lib/syntax/ast/expr.rs +++ b/src/lib/syntax/ast/expr.rs @@ -111,9 +111,9 @@ impl Display for ExprDef { return match *self { ExprDef::ConstExpr(ref c) => write!(f, "{}", c), ExprDef::BlockExpr(ref block) => { - r#try!(write!(f, "{}", "{")); + write!(f, "{}", "{")?; for expr in block.iter() { - r#try!(write!(f, "{};", expr)); + write!(f, "{};", expr)?; } write!(f, "{}", "}") } @@ -121,7 +121,7 @@ impl Display for ExprDef { ExprDef::GetConstFieldExpr(ref ex, ref field) => write!(f, "{}.{}", ex, field), ExprDef::GetFieldExpr(ref ex, ref field) => write!(f, "{}[{}]", ex, field), ExprDef::CallExpr(ref ex, ref args) => { - r#try!(write!(f, "{}(", ex)); + write!(f, "{}(", ex)?; let arg_strs: Vec = args.iter().map(|arg| arg.to_string()).collect(); write!(f, "{})", arg_strs.join(",")) } diff --git a/src/lib/syntax/parser.rs b/src/lib/syntax/parser.rs index 5cfd31bf2d..f5437c1d26 100644 --- a/src/lib/syntax/parser.rs +++ b/src/lib/syntax/parser.rs @@ -52,7 +52,7 @@ impl Parser { pub fn parse_all(&mut self) -> ParseResult { let mut exprs = Vec::new(); while self.pos < self.tokens.len() { - let result = r#try!(self.parse()); + let result = self.parse()?; exprs.push(result); } @@ -72,7 +72,7 @@ impl Parser { fn parse_struct(&mut self, keyword: Keyword) -> ParseResult { match keyword { Keyword::Throw => { - let thrown = r#try!(self.parse()); + let thrown = self.parse()?; Ok(mk!(self, ExprDef::ThrowExpr(Box::new(thrown)))) } // vars, lets and consts are similar in parsing structure, we can group them together @@ -177,10 +177,10 @@ impl Parser { )) } Keyword::Switch => { - r#try!(self.expect_punc(Punctuator::OpenParen, "switch value")); + self.expect_punc(Punctuator::OpenParen, "switch value")?; let value = self.parse(); - r#try!(self.expect_punc(Punctuator::CloseParen, "switch value")); - r#try!(self.expect_punc(Punctuator::OpenBlock, "switch block")); + self.expect_punc(Punctuator::CloseParen, "switch value")?; + self.expect_punc(Punctuator::OpenBlock, "switch block")?; let mut cases = Vec::new(); let mut default = None; while self.pos + 1 < self.tokens.len() { @@ -190,26 +190,26 @@ impl Parser { TokenData::Keyword(Keyword::Case) => { let cond = self.parse(); let mut block = Vec::new(); - r#try!(self.expect_punc(Punctuator::Colon, "switch case")); + self.expect_punc(Punctuator::Colon, "switch case")?; loop { - match r#try!(self.get_token(self.pos)).data { + match self.get_token(self.pos)?.data { TokenData::Keyword(Keyword::Case) | TokenData::Keyword(Keyword::Default) => break, TokenData::Punctuator(Punctuator::CloseBlock) => break, - _ => block.push(r#try!(self.parse())), + _ => block.push(self.parse()?), } } cases.push((cond.unwrap(), block)); } TokenData::Keyword(Keyword::Default) => { let mut block = Vec::new(); - r#try!(self.expect_punc(Punctuator::Colon, "default switch case")); + self.expect_punc(Punctuator::Colon, "default switch case")?; loop { - match r#try!(self.get_token(self.pos)).data { + match self.get_token(self.pos)?.data { TokenData::Keyword(Keyword::Case) | TokenData::Keyword(Keyword::Default) => break, TokenData::Punctuator(Punctuator::CloseBlock) => break, - _ => block.push(r#try!(self.parse())), + _ => block.push(self.parse()?), } } default = Some(mk!(self, ExprDef::BlockExpr(block))); @@ -228,7 +228,7 @@ impl Parser { } } } - r#try!(self.expect_punc(Punctuator::CloseBlock, "switch block")); + self.expect_punc(Punctuator::CloseBlock, "switch block")?; Ok(mk!( self, ExprDef::SwitchExpr( @@ -243,7 +243,7 @@ impl Parser { } Keyword::Function => { // function [identifier] () { etc } - let tk = r#try!(self.get_token(self.pos)); + let tk = self.get_token(self.pos)?; let name = match tk.data { TokenData::Identifier(ref name) => { self.pos += 1; @@ -274,9 +274,7 @@ impl Parser { } } self.pos += 1; - if r#try!(self.get_token(self.pos)).data - == TokenData::Punctuator(Punctuator::Comma) - { + if self.get_token(self.pos)?.data == TokenData::Punctuator(Punctuator::Comma) { self.pos += 1; } tk = self.get_token(self.pos)?; @@ -297,13 +295,13 @@ impl Parser { if self.pos > self.tokens.len() { return Err(ParseError::AbruptEnd); } - let token = r#try!(self.get_token(self.pos)); + let token = self.get_token(self.pos)?; self.pos += 1; let expr: Expr = match token.data { TokenData::Punctuator(Punctuator::Semicolon) | TokenData::Comment(_) if self.pos < self.tokens.len() => { - r#try!(self.parse()) + self.parse()? } TokenData::Punctuator(Punctuator::Semicolon) | TokenData::Comment(_) => { mk!(self, ExprDef::ConstExpr(Const::Undefined)) @@ -316,15 +314,15 @@ impl Parser { mk!(self, ExprDef::ConstExpr(Const::Undefined)) } TokenData::Identifier(s) => mk!(self, ExprDef::LocalExpr(s)), - TokenData::Keyword(keyword) => r#try!(self.parse_struct(keyword)), + TokenData::Keyword(keyword) => self.parse_struct(keyword)?, TokenData::Punctuator(Punctuator::OpenParen) => { - match r#try!(self.get_token(self.pos)).data { + match self.get_token(self.pos)?.data { TokenData::Punctuator(Punctuator::CloseParen) - if r#try!(self.get_token(self.pos + 1)).data + if self.get_token(self.pos + 1)?.data == TokenData::Punctuator(Punctuator::Arrow) => { self.pos += 2; - let expr = r#try!(self.parse()); + let expr = self.parse()?; mk!( self, ExprDef::ArrowFunctionDeclExpr(Vec::new(), Box::new(expr)), @@ -332,8 +330,8 @@ impl Parser { ) } _ => { - let next = r#try!(self.parse()); - let next_tok = r#try!(self.get_token(self.pos)); + let next = self.parse()?; + let next_tok = self.get_token(self.pos)?; self.pos += 1; match next_tok.data { TokenData::Punctuator(Punctuator::CloseParen) => next, @@ -344,7 +342,7 @@ impl Parser { ExprDef::LocalExpr(ref name) => (*name).clone(), _ => "".to_string(), }, - match r#try!(self.get_token(self.pos)).data { + match self.get_token(self.pos)?.data { TokenData::Identifier(ref id) => id.clone(), _ => "".to_string(), }, @@ -352,7 +350,7 @@ impl Parser { let mut expect_ident = true; loop { self.pos += 1; - let curr_tk = r#try!(self.get_token(self.pos)); + let curr_tk = self.get_token(self.pos)?; match curr_tk.data { TokenData::Identifier(ref id) if expect_ident => { args.push(id.clone()); @@ -386,11 +384,11 @@ impl Parser { } } } - r#try!(self.expect( + self.expect( TokenData::Punctuator(Punctuator::Arrow), - "arrow function" - )); - let expr = r#try!(self.parse()); + "arrow function", + )?; + let expr = self.parse()?; mk!( self, ExprDef::ArrowFunctionDeclExpr(args, Box::new(expr)), @@ -410,10 +408,10 @@ impl Parser { } TokenData::Punctuator(Punctuator::OpenBracket) => { let mut array: Vec = Vec::new(); - let mut expect_comma_or_end = r#try!(self.get_token(self.pos)).data + let mut expect_comma_or_end = self.get_token(self.pos)?.data == TokenData::Punctuator(Punctuator::CloseBracket); loop { - let token = r#try!(self.get_token(self.pos)); + let token = self.get_token(self.pos)?; if token.data == TokenData::Punctuator(Punctuator::CloseBracket) && expect_comma_or_end { @@ -438,7 +436,7 @@ impl Parser { "array declaration", )); } else { - let parsed = r#try!(self.parse()); + let parsed = self.parse()?; self.pos -= 1; array.push(parsed); expect_comma_or_end = true; @@ -448,7 +446,7 @@ impl Parser { mk!(self, ExprDef::ArrayDeclExpr(array), token) } TokenData::Punctuator(Punctuator::OpenBlock) - if r#try!(self.get_token(self.pos)).data + if self.get_token(self.pos)?.data == TokenData::Punctuator(Punctuator::CloseBlock) => { self.pos += 1; @@ -459,15 +457,14 @@ impl Parser { ) } TokenData::Punctuator(Punctuator::OpenBlock) - if r#try!(self.get_token(self.pos + 1)).data + if self.get_token(self.pos + 1)?.data == TokenData::Punctuator(Punctuator::Colon) => { let mut map = Box::new(BTreeMap::new()); - while r#try!(self.get_token(self.pos - 1)).data - == TokenData::Punctuator(Punctuator::Comma) + while self.get_token(self.pos - 1)?.data == TokenData::Punctuator(Punctuator::Comma) || map.len() == 0 { - let tk = r#try!(self.get_token(self.pos)); + let tk = self.get_token(self.pos)?; let name = match tk.data { TokenData::Identifier(ref id) => id.clone(), TokenData::StringLiteral(ref str) => str.clone(), @@ -483,11 +480,11 @@ impl Parser { } }; self.pos += 1; - r#try!(self.expect( + self.expect( TokenData::Punctuator(Punctuator::Colon), - "object declaration" - )); - let value = r#try!(self.parse()); + "object declaration", + )?; + let value = self.parse()?; map.insert(name, value); self.pos += 1; } @@ -496,12 +493,12 @@ impl Parser { TokenData::Punctuator(Punctuator::OpenBlock) => { let mut exprs = Vec::new(); loop { - if r#try!(self.get_token(self.pos)).data + if self.get_token(self.pos)?.data == TokenData::Punctuator(Punctuator::CloseBlock) { break; } else { - exprs.push(r#try!(self.parse())); + exprs.push(self.parse()?); } } self.pos += 1; @@ -509,23 +506,23 @@ impl Parser { } TokenData::Punctuator(Punctuator::Sub) => mk!( self, - ExprDef::UnaryOpExpr(UnaryOp::Minus, Box::new(r#try!(self.parse()))) + ExprDef::UnaryOpExpr(UnaryOp::Minus, Box::new(self.parse()?)) ), TokenData::Punctuator(Punctuator::Add) => mk!( self, - ExprDef::UnaryOpExpr(UnaryOp::Plus, Box::new(r#try!(self.parse()))) + ExprDef::UnaryOpExpr(UnaryOp::Plus, Box::new(self.parse()?)) ), TokenData::Punctuator(Punctuator::Not) => mk!( self, - ExprDef::UnaryOpExpr(UnaryOp::Not, Box::new(r#try!(self.parse()))) + ExprDef::UnaryOpExpr(UnaryOp::Not, Box::new(self.parse()?)) ), TokenData::Punctuator(Punctuator::Inc) => mk!( self, - ExprDef::UnaryOpExpr(UnaryOp::IncrementPre, Box::new(r#try!(self.parse()))) + ExprDef::UnaryOpExpr(UnaryOp::IncrementPre, Box::new(self.parse()?)) ), TokenData::Punctuator(Punctuator::Dec) => mk!( self, - ExprDef::UnaryOpExpr(UnaryOp::DecrementPre, Box::new(r#try!(self.parse()))) + ExprDef::UnaryOpExpr(UnaryOp::DecrementPre, Box::new(self.parse()?)) ), _ => return Err(ParseError::Expected(Vec::new(), token.clone(), "script")), }; @@ -543,7 +540,7 @@ impl Parser { match next.data { TokenData::Punctuator(Punctuator::Dot) => { self.pos += 1; - let tk = r#try!(self.get_token(self.pos)); + let tk = self.get_token(self.pos)?; match tk.data { TokenData::Identifier(ref s) => { result = mk!( @@ -563,11 +560,11 @@ impl Parser { } TokenData::Punctuator(Punctuator::OpenParen) => { let mut args = Vec::new(); - let mut expect_comma_or_end = r#try!(self.get_token(self.pos + 1)).data + let mut expect_comma_or_end = self.get_token(self.pos + 1)?.data == TokenData::Punctuator(Punctuator::CloseParen); loop { self.pos += 1; - let token = r#try!(self.get_token(self.pos)); + let token = self.get_token(self.pos)?; if token.data == TokenData::Punctuator(Punctuator::CloseParen) && expect_comma_or_end { @@ -587,7 +584,7 @@ impl Parser { "function call arguments", )); } else { - let parsed = r#try!(self.parse()); + let parsed = self.parse()?; self.pos -= 1; args.push(parsed); expect_comma_or_end = true; @@ -597,9 +594,9 @@ impl Parser { } TokenData::Punctuator(Punctuator::Question) => { self.pos += 1; - let if_e = r#try!(self.parse()); - r#try!(self.expect(TokenData::Punctuator(Punctuator::Colon), "if expression")); - let else_e = r#try!(self.parse()); + let if_e = self.parse()?; + self.expect(TokenData::Punctuator(Punctuator::Colon), "if expression")?; + let else_e = self.parse()?; result = mk!( self, ExprDef::IfExpr(Box::new(expr), Box::new(if_e), Some(Box::new(else_e))) @@ -607,11 +604,11 @@ impl Parser { } TokenData::Punctuator(Punctuator::OpenBracket) => { self.pos += 1; - let index = r#try!(self.parse()); - r#try!(self.expect( + let index = self.parse()?; + self.expect( TokenData::Punctuator(Punctuator::CloseBracket), - "array index" - )); + "array index", + )?; result = mk!(self, ExprDef::GetFieldExpr(Box::new(expr), Box::new(index))); } TokenData::Punctuator(Punctuator::Semicolon) | TokenData::Comment(_) => { @@ -619,7 +616,7 @@ impl Parser { } TokenData::Punctuator(Punctuator::Assign) => { self.pos += 1; - let next = r#try!(self.parse()); + let next = self.parse()?; result = mk!(self, ExprDef::AssignExpr(Box::new(expr), Box::new(next))); } TokenData::Punctuator(Punctuator::Arrow) => { @@ -629,79 +626,79 @@ impl Parser { ExprDef::LocalExpr(ref name) => args.push((*name).clone()), _ => return Err(ParseError::ExpectedExpr("identifier", result)), } - let next = r#try!(self.parse()); + let next = self.parse()?; result = mk!(self, ExprDef::ArrowFunctionDeclExpr(args, Box::new(next))); } TokenData::Punctuator(Punctuator::Add) => { - result = r#try!(self.binop(BinOp::Num(NumOp::Add), expr)) + result = self.binop(BinOp::Num(NumOp::Add), expr)? } TokenData::Punctuator(Punctuator::Sub) => { - result = r#try!(self.binop(BinOp::Num(NumOp::Sub), expr)) + result = self.binop(BinOp::Num(NumOp::Sub), expr)? } TokenData::Punctuator(Punctuator::Mul) => { - result = r#try!(self.binop(BinOp::Num(NumOp::Mul), expr)) + result = self.binop(BinOp::Num(NumOp::Mul), expr)? } TokenData::Punctuator(Punctuator::Div) => { - result = r#try!(self.binop(BinOp::Num(NumOp::Div), expr)) + result = self.binop(BinOp::Num(NumOp::Div), expr)? } TokenData::Punctuator(Punctuator::Mod) => { - result = r#try!(self.binop(BinOp::Num(NumOp::Mod), expr)) + result = self.binop(BinOp::Num(NumOp::Mod), expr)? } TokenData::Punctuator(Punctuator::BoolAnd) => { - result = r#try!(self.binop(BinOp::Log(LogOp::And), expr)) + result = self.binop(BinOp::Log(LogOp::And), expr)? } TokenData::Punctuator(Punctuator::BoolOr) => { - result = r#try!(self.binop(BinOp::Log(LogOp::Or), expr)) + result = self.binop(BinOp::Log(LogOp::Or), expr)? } TokenData::Punctuator(Punctuator::And) => { - result = r#try!(self.binop(BinOp::Bit(BitOp::And), expr)) + result = self.binop(BinOp::Bit(BitOp::And), expr)? } TokenData::Punctuator(Punctuator::Or) => { - result = r#try!(self.binop(BinOp::Bit(BitOp::Or), expr)) + result = self.binop(BinOp::Bit(BitOp::Or), expr)? } TokenData::Punctuator(Punctuator::Xor) => { - result = r#try!(self.binop(BinOp::Bit(BitOp::Xor), expr)) + result = self.binop(BinOp::Bit(BitOp::Xor), expr)? } TokenData::Punctuator(Punctuator::LeftSh) => { - result = r#try!(self.binop(BinOp::Bit(BitOp::Shl), expr)) + result = self.binop(BinOp::Bit(BitOp::Shl), expr)? } TokenData::Punctuator(Punctuator::RightSh) => { - result = r#try!(self.binop(BinOp::Bit(BitOp::Shr), expr)) + result = self.binop(BinOp::Bit(BitOp::Shr), expr)? } TokenData::Punctuator(Punctuator::Eq) => { - result = r#try!(self.binop(BinOp::Comp(CompOp::Equal), expr)) + result = self.binop(BinOp::Comp(CompOp::Equal), expr)? } TokenData::Punctuator(Punctuator::NotEq) => { - result = r#try!(self.binop(BinOp::Comp(CompOp::NotEqual), expr)) + result = self.binop(BinOp::Comp(CompOp::NotEqual), expr)? } TokenData::Punctuator(Punctuator::StrictEq) => { - result = r#try!(self.binop(BinOp::Comp(CompOp::StrictEqual), expr)) + result = self.binop(BinOp::Comp(CompOp::StrictEqual), expr)? } TokenData::Punctuator(Punctuator::StrictNotEq) => { - result = r#try!(self.binop(BinOp::Comp(CompOp::StrictNotEqual), expr)) + result = self.binop(BinOp::Comp(CompOp::StrictNotEqual), expr)? } TokenData::Punctuator(Punctuator::LessThan) => { - result = r#try!(self.binop(BinOp::Comp(CompOp::LessThan), expr)) + result = self.binop(BinOp::Comp(CompOp::LessThan), expr)? } TokenData::Punctuator(Punctuator::LessThanOrEq) => { - result = r#try!(self.binop(BinOp::Comp(CompOp::LessThanOrEqual), expr)) + result = self.binop(BinOp::Comp(CompOp::LessThanOrEqual), expr)? } TokenData::Punctuator(Punctuator::GreaterThan) => { - result = r#try!(self.binop(BinOp::Comp(CompOp::GreaterThan), expr)) + result = self.binop(BinOp::Comp(CompOp::GreaterThan), expr)? } TokenData::Punctuator(Punctuator::GreaterThanOrEq) => { - result = r#try!(self.binop(BinOp::Comp(CompOp::GreaterThanOrEqual), expr)) + result = self.binop(BinOp::Comp(CompOp::GreaterThanOrEqual), expr)? } TokenData::Punctuator(Punctuator::Inc) => { result = mk!( self, - ExprDef::UnaryOpExpr(UnaryOp::IncrementPost, Box::new(r#try!(self.parse()))) + ExprDef::UnaryOpExpr(UnaryOp::IncrementPost, Box::new(self.parse()?)) ) } TokenData::Punctuator(Punctuator::Dec) => { result = mk!( self, - ExprDef::UnaryOpExpr(UnaryOp::DecrementPost, Box::new(r#try!(self.parse()))) + ExprDef::UnaryOpExpr(UnaryOp::DecrementPost, Box::new(self.parse()?)) ) } _ => carry_on = false, @@ -716,7 +713,7 @@ impl Parser { fn binop(&mut self, op: BinOp, orig: Expr) -> Result { let (precedence, assoc) = op.get_precedence_and_assoc(); self.pos += 1; - let next = r#try!(self.parse()); + let next = self.parse()?; Ok(match next.def { ExprDef::BinOpExpr(ref op2, ref a, ref b) => { let other_precedence = op2.get_precedence();