Parse try blocks with the try keyword instead of do catch placeholder

Author: scottmcm

src/librustc_mir/borrow_check/nll/mod.rs

@@ -312,14 +312,14 @@ fn dump_mir_results<'a, 'gcx, 'tcx>(
     );
 
     // Also dump the inference graph constraints as a graphviz file.
-    let _: io::Result<()> = do catch {
+    let _: io::Result<()> = try_block! {
         let mut file =
             pretty::create_dump_file(infcx.tcx, "regioncx.all.dot", None, "nll", &0, source)?;
         regioncx.dump_graphviz_raw_constraints(&mut file)?;
     };
 
     // Also dump the inference graph constraints as a graphviz file.
-    let _: io::Result<()> = do catch {
+    let _: io::Result<()> = try_block! {
         let mut file =
             pretty::create_dump_file(infcx.tcx, "regioncx.scc.dot", None, "nll", &0, source)?;
         regioncx.dump_graphviz_scc_constraints(&mut file)?;

src/librustc_mir/lib.rs

@@ -21,7 +21,6 @@ Rust MIR: a lowered representation of Rust. Also: an experiment!
 #![feature(slice_sort_by_cached_key)]
 #![feature(box_patterns)]
 #![feature(box_syntax)]
-#![feature(catch_expr)]
 #![feature(crate_visibility_modifier)]
 #![feature(const_fn)]
 #![feature(core_intrinsics)]
@@ -61,6 +60,14 @@ extern crate rustc_apfloat;
 extern crate byteorder;
 extern crate core;
 
+// Once we can use edition 2018 in the compiler,
+// replace this with real try blocks.
+macro_rules! try_block {
+    ($($inside:tt)*) => (
+        (||{ ::std::ops::Try::from_ok({ $($inside)* }) })()
+    )
+}
+
 mod diagnostics;
 
 mod borrow_check;

src/librustc_mir/util/pretty.rs

@@ -140,7 +140,7 @@ fn dump_matched_mir_node<'a, 'gcx, 'tcx, F>(
 ) where
     F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
 {
-    let _: io::Result<()> = do catch {
+    let _: io::Result<()> = try_block! {
         let mut file = create_dump_file(tcx, "mir", pass_num, pass_name, disambiguator, source)?;
         writeln!(file, "// MIR for `{}`", node_path)?;
         writeln!(file, "// source = {:?}", source)?;
@@ -156,7 +156,7 @@ fn dump_matched_mir_node<'a, 'gcx, 'tcx, F>(
     };
 
     if tcx.sess.opts.debugging_opts.dump_mir_graphviz {
-        let _: io::Result<()> = do catch {
+        let _: io::Result<()> = try_block! {
             let mut file =
                 create_dump_file(tcx, "dot", pass_num, pass_name, disambiguator, source)?;
             write_mir_fn_graphviz(tcx, source.def_id, mir, &mut file)?;

src/librustc_typeck/check/mod.rs

@@ -4461,7 +4461,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         // In some cases, blocks have just one exit, but other blocks
         // can be targeted by multiple breaks. This can happen both
         // with labeled blocks as well as when we desugar
-        // a `do catch { ... }` expression.
+        // a `try { ... }` expression.
         //
         // Example 1:
         //

src/libsyntax/feature_gate.rs

@@ -330,7 +330,7 @@ declare_features! (
     // `extern "x86-interrupt" fn()`
     (active, abi_x86_interrupt, "1.17.0", Some(40180), None),
 
-    // Allows the `catch {...}` expression
+    // Allows the `try {...}` expression
     (active, catch_expr, "1.17.0", Some(31436), None),
 
     // Used to preserve symbols (see llvm.used)
@@ -1735,7 +1735,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                                   "yield syntax is experimental");
             }
             ast::ExprKind::TryBlock(_) => {
-                gate_feature_post!(&self, catch_expr, e.span, "`catch` expression is experimental");
+                gate_feature_post!(&self, catch_expr, e.span, "`try` expression is experimental");
             }
             ast::ExprKind::IfLet(ref pats, ..) | ast::ExprKind::WhileLet(ref pats, ..) => {
                 if pats.len() > 1 {

src/libsyntax/parse/parser.rs

@@ -2386,11 +2386,10 @@ impl<'a> Parser<'a> {
                         BlockCheckMode::Unsafe(ast::UserProvided),
                         attrs);
                 }
-                if self.is_catch_expr() {
+                if self.is_try_block() {
                     let lo = self.span;
-                    assert!(self.eat_keyword(keywords::Do));
-                    assert!(self.eat_keyword(keywords::Catch));
-                    return self.parse_catch_expr(lo, attrs);
+                    assert!(self.eat_keyword(keywords::Try));
+                    return self.parse_try_block(lo, attrs);
                 }
                 if self.eat_keyword(keywords::Return) {
                     if self.token.can_begin_expr() {
@@ -3452,8 +3451,8 @@ impl<'a> Parser<'a> {
             ExprKind::Async(capture_clause, ast::DUMMY_NODE_ID, body), attrs))
     }
 
-    /// Parse a `do catch {...}` expression (`do catch` token already eaten)
-    fn parse_catch_expr(&mut self, span_lo: Span, mut attrs: ThinVec<Attribute>)
+    /// Parse a `try {...}` expression (`try` token already eaten)
+    fn parse_try_block(&mut self, span_lo: Span, mut attrs: ThinVec<Attribute>)
         -> PResult<'a, P<Expr>>
     {
         let (iattrs, body) = self.parse_inner_attrs_and_block()?;
@@ -4407,12 +4406,13 @@ impl<'a> Parser<'a> {
         )
     }
 
-    fn is_catch_expr(&mut self) -> bool {
-        self.token.is_keyword(keywords::Do) &&
-        self.look_ahead(1, |t| t.is_keyword(keywords::Catch)) &&
-        self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace)) &&
+    fn is_try_block(&mut self) -> bool {
+        self.token.is_keyword(keywords::Try) &&
+        self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) &&
 
-        // prevent `while catch {} {}`, `if catch {} {} else {}`, etc.
+        self.span.edition() >= Edition::Edition2018 &&
+
+        // prevent `while try {} {}`, `if try {} {} else {}`, etc.
         !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL)
     }
 

src/libsyntax/print/pprust.rs

@@ -2380,7 +2380,7 @@ impl<'a> State<'a> {
                 self.s.word("?")?
             }
             ast::ExprKind::TryBlock(ref blk) => {
-                self.head("do catch")?;
+                self.head("try")?;
                 self.s.space()?;
                 self.print_block_with_attrs(blk, attrs)?
             }

src/libsyntax_pos/hygiene.rs

@@ -609,7 +609,7 @@ impl CompilerDesugaringKind {
         Symbol::intern(match self {
             CompilerDesugaringKind::Async => "async",
             CompilerDesugaringKind::QuestionMark => "?",
-            CompilerDesugaringKind::TryBlock => "do catch",
+            CompilerDesugaringKind::TryBlock => "try block",
             CompilerDesugaringKind::ExistentialReturnType => "existential type",
             CompilerDesugaringKind::ForLoop => "for loop",
         })

src/test/ui/catch/catch-bad-lifetime.rs renamed to src/test/compile-fail/try-block-bad-lifetime.rs

@@ -8,14 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// compile-flags: --edition 2018
+
 #![feature(catch_expr)]
 
-// This test checks that borrows made and returned inside catch blocks are properly constrained
+// This test checks that borrows made and returned inside try blocks are properly constrained
 pub fn main() {
     {
-        // Test that borrows returned from a catch block must be valid for the lifetime of the
+        // Test that borrows returned from a try block must be valid for the lifetime of the
         // result variable
-        let _result: Result<(), &str> = do catch {
+        let _result: Result<(), &str> = try {
             let my_string = String::from("");
             let my_str: & str = & my_string;
             //~^ ERROR `my_string` does not live long enough
@@ -25,10 +27,10 @@ pub fn main() {
     }
 
     {
-        // Test that borrows returned from catch blocks freeze their referent
+        // Test that borrows returned from try blocks freeze their referent
         let mut i = 5;
         let k = &mut i;
-        let mut j: Result<(), &mut i32> = do catch {
+        let mut j: Result<(), &mut i32> = try {
             Err(k) ?;
             i = 10; //~ ERROR cannot assign to `i` because it is borrowed
         };

src/test/ui/catch/catch-bad-type.rs renamed to src/test/compile-fail/try-block-bad-type.rs

@@ -8,21 +8,23 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// compile-flags: --edition 2018
+
 #![feature(catch_expr)]
 
 pub fn main() {
-    let res: Result<u32, i32> = do catch {
+    let res: Result<u32, i32> = try {
         Err("")?; //~ ERROR the trait bound `i32: std::convert::From<&str>` is not satisfied
         5
     };
 
-    let res: Result<i32, i32> = do catch {
+    let res: Result<i32, i32> = try {
         "" //~ ERROR type mismatch
     };
 
-    let res: Result<i32, i32> = do catch { }; //~ ERROR type mismatch
+    let res: Result<i32, i32> = try { }; //~ ERROR type mismatch
 
-    let res: () = do catch { }; //~ the trait bound `(): std::ops::Try` is not satisfied
+    let res: () = try { }; //~ the trait bound `(): std::ops::Try` is not satisfied
 
-    let res: i32 = do catch { 5 }; //~ ERROR the trait bound `i32: std::ops::Try` is not satisfied
+    let res: i32 = try { 5 }; //~ ERROR the trait bound `i32: std::ops::Try` is not satisfied
 }