trait_impls: BTreeMap<DefId, Vec<NodeId>>,
trait_default_impl: BTreeMap<DefId, NodeId>,
+ catch_scopes: Vec<NodeId>,
loop_scopes: Vec<NodeId>,
is_in_loop_condition: bool,
trait_impls: BTreeMap::new(),
trait_default_impl: BTreeMap::new(),
exported_macros: Vec::new(),
+ catch_scopes: Vec::new(),
loop_scopes: Vec::new(),
is_in_loop_condition: false,
type_def_lifetime_params: DefIdMap(),
span
}
+ fn with_catch_scope<T, F>(&mut self, catch_id: NodeId, f: F) -> T
+ where F: FnOnce(&mut LoweringContext) -> T
+ {
+ let len = self.catch_scopes.len();
+ self.catch_scopes.push(catch_id);
+
+ let result = f(self);
+ assert_eq!(len + 1, self.catch_scopes.len(),
+ "catch scopes should be added and removed in stack order");
+
+ self.catch_scopes.pop().unwrap();
+
+ result
+ }
+
fn with_loop_scope<T, F>(&mut self, loop_id: NodeId, f: F) -> T
where F: FnOnce(&mut LoweringContext) -> T
{
result
}
- fn with_new_loop_scopes<T, F>(&mut self, f: F) -> T
+ fn with_new_scopes<T, F>(&mut self, f: F) -> T
where F: FnOnce(&mut LoweringContext) -> T
{
let was_in_loop_condition = self.is_in_loop_condition;
self.is_in_loop_condition = false;
+ let catch_scopes = mem::replace(&mut self.catch_scopes, Vec::new());
let loop_scopes = mem::replace(&mut self.loop_scopes, Vec::new());
let result = f(self);
- mem::replace(&mut self.loop_scopes, loop_scopes);
+ self.catch_scopes = catch_scopes;
+ self.loop_scopes = loop_scopes;
self.is_in_loop_condition = was_in_loop_condition;
self.record_body(value, None))
}
ItemKind::Fn(ref decl, unsafety, constness, abi, ref generics, ref body) => {
- self.with_new_loop_scopes(|this| {
+ self.with_new_scopes(|this| {
let body = this.lower_block(body);
let body = this.expr_block(body, ThinVec::new());
let body_id = this.record_body(body, Some(decl));
this.lower_opt_sp_ident(opt_ident),
hir::LoopSource::Loop))
}
+ ExprKind::Catch(ref body) => {
+ // FIXME(cramertj): Add catch to HIR
+ self.with_catch_scope(e.id, |this| hir::ExprBlock(this.lower_block(body)))
+ }
ExprKind::Match(ref expr, ref arms) => {
hir::ExprMatch(P(self.lower_expr(expr)),
arms.iter().map(|x| self.lower_arm(x)).collect(),
hir::MatchSource::Normal)
}
ExprKind::Closure(capture_clause, ref decl, ref body, fn_decl_span) => {
- self.with_new_loop_scopes(|this| {
+ self.with_new_scopes(|this| {
this.with_parent_def(e.id, |this| {
let expr = this.lower_expr(body);
hir::ExprClosure(this.lower_capture_clause(capture_clause),
// Err(err) => #[allow(unreachable_code)]
// return Carrier::from_error(From::from(err)),
// }
+
+ // FIXME(cramertj): implement breaking to catch
+ if !self.catch_scopes.is_empty() {
+ bug!("`?` in catch scopes is unimplemented")
+ }
+
let unstable_span = self.allow_internal_unstable("?", e.span);
// Carrier::translate(<expr>)
Closure(CaptureBy, P<FnDecl>, P<Expr>, Span),
/// A block (`{ ... }`)
Block(P<Block>),
+ /// A catch block (`catch { ... }`)
+ Catch(P<Block>),
/// An assignment (`a = foo()`)
Assign(P<Expr>, P<Expr>),
// `extern "x86-interrupt" fn()`
(active, abi_x86_interrupt, "1.17.0", Some(40180)),
+
+ // Allows the `catch {...}` expression
+ (active, catch_expr, "1.17.0", Some(31436)),
);
declare_features! (
}
}
}
+ ast::ExprKind::Catch(_) => {
+ gate_feature_post!(&self, catch_expr, e.span, "`catch` expression is experimental");
+ }
_ => {}
}
visit::walk_expr(self, e);
};
}
ExprKind::Try(ex) => ExprKind::Try(folder.fold_expr(ex)),
+ ExprKind::Catch(body) => ExprKind::Catch(folder.fold_block(body)),
},
id: folder.new_id(id),
span: folder.new_span(span),
}
}
+ pub fn error_if_typename_is_catch(&mut self, ident: ast::Ident) {
+ if ident.name == keywords::Catch.name() {
+ self.span_err(self.span, "cannot use `catch` as the name of a type");
+ }
+ }
+
/// Check if the next token is `tok`, and return `true` if so.
///
/// This method will automatically add `tok` to `expected_tokens` if `tok` is not
BlockCheckMode::Unsafe(ast::UserProvided),
attrs);
}
+ if self.is_catch_expr() {
+ assert!(self.eat_keyword(keywords::Catch));
+ let lo = self.prev_span.lo;
+ return self.parse_catch_expr(lo, attrs);
+ }
if self.eat_keyword(keywords::Return) {
if self.token.can_begin_expr() {
let e = self.parse_expr()?;
Ok(self.mk_expr(span_lo, hi, ExprKind::Loop(body, opt_ident), attrs))
}
+ /// Parse a `catch {...}` expression (`catch` token already eaten)
+ pub fn parse_catch_expr(&mut self, span_lo: BytePos, mut attrs: ThinVec<Attribute>)
+ -> PResult<'a, P<Expr>>
+ {
+ let (iattrs, body) = self.parse_inner_attrs_and_block()?;
+ attrs.extend(iattrs);
+ let hi = body.span.hi;
+ Ok(self.mk_expr(span_lo, hi, ExprKind::Catch(body), attrs))
+ }
+
// `match` token already eaten
fn parse_match_expr(&mut self, mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
let match_span = self.prev_span;
})
}
+ fn is_catch_expr(&mut self) -> bool {
+ self.token.is_keyword(keywords::Catch) &&
+ self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) &&
+
+ // prevent `while catch {} {}`, `if catch {} {} else {}`, etc.
+ !self.restrictions.contains(Restrictions::RESTRICTION_NO_STRUCT_LITERAL)
+ }
+
fn is_union_item(&self) -> bool {
self.token.is_keyword(keywords::Union) &&
self.look_ahead(1, |t| t.is_ident() && !t.is_any_keyword())
/// Parse struct Foo { ... }
fn parse_item_struct(&mut self) -> PResult<'a, ItemInfo> {
let class_name = self.parse_ident()?;
+ self.error_if_typename_is_catch(class_name);
+
let mut generics = self.parse_generics()?;
// There is a special case worth noting here, as reported in issue #17904.
/// Parse union Foo { ... }
fn parse_item_union(&mut self) -> PResult<'a, ItemInfo> {
let class_name = self.parse_ident()?;
+ self.error_if_typename_is_catch(class_name);
+
let mut generics = self.parse_generics()?;
let vdata = if self.token.is_keyword(keywords::Where) {
let struct_def;
let mut disr_expr = None;
let ident = self.parse_ident()?;
+ self.error_if_typename_is_catch(ident);
if self.check(&token::OpenDelim(token::Brace)) {
// Parse a struct variant.
all_nullary = false;
/// Parse an "enum" declaration
fn parse_item_enum(&mut self) -> PResult<'a, ItemInfo> {
let id = self.parse_ident()?;
+ self.error_if_typename_is_catch(id);
let mut generics = self.parse_generics()?;
generics.where_clause = self.parse_where_clause()?;
self.expect(&token::OpenDelim(token::Brace))?;
self.print_expr(e)?;
word(&mut self.s, "?")?
}
+ ast::ExprKind::Catch(ref blk) => {
+ self.head("catch")?;
+ space(&mut self.s)?;
+ self.print_block_with_attrs(&blk, attrs)?
+ }
}
self.ann.post(self, NodeExpr(expr))?;
self.end()
(53, Default, "default")
(54, StaticLifetime, "'static")
(55, Union, "union")
+ (56, Catch, "catch")
// A virtual keyword that resolves to the crate root when used in a lexical scope.
- (56, CrateRoot, "{{root}}")
+ (57, CrateRoot, "{{root}}")
}
// If an interner exists in TLS, return it. Otherwise, prepare a fresh one.
ExprKind::Try(ref subexpression) => {
visitor.visit_expr(subexpression)
}
+ ExprKind::Catch(ref body) => {
+ visitor.visit_block(body)
+ }
}
visitor.visit_expr_post(expression)
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+#![feature(catch_expr)]
+
+struct catch; //~ ERROR cannot use `catch` as the name of a type
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+#![feature(catch_expr)]
+
+enum Enum {
+ catch {} //~ ERROR cannot use `catch` as the name of a type
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+#![feature(catch_expr)]
+
+struct catch {} //~ ERROR cannot use `catch` as the name of a type
\ No newline at end of file
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+#![feature(catch_expr)]
+
+struct catch(); //~ ERROR cannot use `catch` as the name of a type
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub fn main() {
+ let catch_result = catch { //~ ERROR `catch` expression is experimental
+ let x = 5;
+ x
+ };
+ assert_eq!(catch_result, 5);
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(catch_expr)]
+
+pub fn main() {
+ let catch_result = catch {
+ let x = 5;
+ x
+ };
+ assert_eq!(catch_result, 5);
+
+ let mut catch = true;
+ while catch { catch = false; }
+ assert_eq!(catch, false);
+
+ catch = if catch { false } else { true };
+ assert_eq!(catch, true);
+
+ match catch {
+ _ => {}
+ };
+}