diff --git a/src/expr.rs b/src/expr.rs
index 69a3389..3068082 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -176,6 +176,11 @@
 
     /// `expr?`
     Try(Box<Expr>),
+
+    /// A catch expression.
+    ///
+    /// E.g. `do catch { block }`
+    Catch(Block),
 }
 
 /// A field-value pair in a struct literal.
@@ -427,6 +432,8 @@
                 |
                 expr_match
                 |
+                expr_catch
+                |
                 call!(expr_closure, allow_struct)
                 |
                 cond_reduce!(allow_block, expr_block)
@@ -677,6 +684,13 @@
         }))
     ));
 
+    named!(expr_catch -> ExprKind, do_parse!(
+        keyword!("do") >>
+        keyword!("catch") >>
+        catch_block: block >>
+        (ExprKind::Catch(catch_block))
+    ));
+
     fn arm_requires_comma(arm: &Arm) -> bool {
         if let ExprKind::Block(Unsafety::Normal, _) = arm.body.node {
             false
@@ -1337,6 +1351,11 @@
                     tokens.append_all(arms);
                     tokens.append("}");
                 }
+                ExprKind::Catch(ref body) => {
+                    tokens.append("do");
+                    tokens.append("catch");
+                    body.to_tokens(tokens);
+                }
                 ExprKind::Closure(capture, ref decl, ref expr) => {
                     capture.to_tokens(tokens);
                     tokens.append("|");
diff --git a/src/fold.rs b/src/fold.rs
index 2874118..9afda63 100644
--- a/src/fold.rs
+++ b/src/fold.rs
@@ -686,6 +686,9 @@
                     }
                 }))
             }
+            Catch(block) => {
+                Catch(folder.fold_block(block))
+            }
             Closure(capture_by, fn_decl, expr) => {
                 Closure(capture_by,
                         fn_decl.lift(|v| folder.fold_fn_decl(v)),
diff --git a/src/visit.rs b/src/visit.rs
index 8c8645d..879005b 100644
--- a/src/visit.rs
+++ b/src/visit.rs
@@ -502,6 +502,9 @@
                 visitor.visit_expr(body);
             }
         }
+        ExprKind::Catch(ref body) => {
+            walk_list!(visitor, visit_stmt, &body.stmts);
+        }
         ExprKind::Closure(_, ref decl, ref expr) => {
             visitor.visit_fn_decl(decl);
             visitor.visit_expr(expr);
diff --git a/tests/test_expr.rs b/tests/test_expr.rs
new file mode 100644
index 0000000..dca8603
--- /dev/null
+++ b/tests/test_expr.rs
@@ -0,0 +1,136 @@
+extern crate syn;
+use syn::*;
+
+macro_rules! assert_let {
+    ($p:pat = $e:expr) => {
+        assert_let!($p = $e; {})
+    };
+
+    ($p:pat = $e:expr; $body:block) => {
+        if let $p = $e
+            $body
+        else {
+            panic!("Expected to match {} but got {:?}", stringify!($p), $e)
+        }
+    };
+}
+
+#[test]
+#[cfg(feature = "full")]
+fn test_catch_expr() {
+    // Taken from tests/rust/src/test/run-pass/catch-expr.rs
+    let raw = r#"
+        struct catch {}
+
+        pub fn main() {
+            let catch_result = do 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 {
+                _ => {}
+            };
+
+            let catch_err = do catch {
+                Err(22)?;
+                Ok(1)
+            };
+            assert_eq!(catch_err, Err(22));
+
+            let catch_okay: Result<i32, i32> = do catch {
+                if false { Err(25)?; }
+                Ok::<(), i32>(())?;
+                Ok(28)
+            };
+            assert_eq!(catch_okay, Ok(28));
+
+            let catch_from_loop: Result<i32, i32> = do catch {
+                for i in 0..10 {
+                    if i < 5 { Ok::<i32, i32>(i)?; } else { Err(i)?; }
+                }
+                Ok(22)
+            };
+            assert_eq!(catch_from_loop, Err(5));
+
+            let cfg_init;
+            let _res: Result<(), ()> = do catch {
+                cfg_init = 5;
+                Ok(())
+            };
+            assert_eq!(cfg_init, 5);
+
+            let cfg_init_2;
+            let _res: Result<(), ()> = do catch {
+                cfg_init_2 = 6;
+                Err(())?;
+                Ok(())
+            };
+            assert_eq!(cfg_init_2, 6);
+
+            let my_string = "test".to_string();
+            let res: Result<&str, ()> = do catch {
+                Ok(&my_string)
+            };
+            assert_eq!(res, Ok("test"));
+        }
+    "#;
+
+    let actual = parse_crate(raw).unwrap();
+
+    assert_eq!(&actual.items[0].ident, "catch");
+
+    assert_let!(ItemKind::Struct(..) = actual.items[0].node);
+
+    assert_let!(Item { node: ItemKind::Fn(_, _, _, _, _, ref body), .. } = actual.items[1]; {
+        assert_let!(Stmt::Local(ref local) = body.stmts[0]; {
+            assert_let!(Local { init: Some(ref init_expr), .. } = **local; {
+                assert_let!(Expr { node: ExprKind::Catch(..), .. } = **init_expr);
+            });
+        });
+
+        assert_let!(Stmt::Local(ref local) = body.stmts[2]; {
+            assert_let!(Pat::Ident(BindingMode::ByValue(Mutability::Mutable), ref ident, None) = *local.pat; {
+                assert_eq!(ident, "catch");
+            });
+        });
+
+        assert_let!(Stmt::Expr(ref expr) = body.stmts[3]; {
+            assert_let!(Expr { node: ExprKind::While(ref loop_expr, _, None), .. } = **expr; {
+                assert_let!(Expr { node: ExprKind::Path(None, ref loop_var), .. } = **loop_expr; {
+                    assert_eq!(*loop_var, "catch".into());
+                });
+            });
+        });
+
+        assert_let!(Stmt::Semi(ref expr) = body.stmts[5]; {
+            assert_let!(Expr { node: ExprKind::Assign(ref left, ref right), .. } = **expr; {
+                assert_let!(Expr { node: ExprKind::Path(None, ref loop_var), .. } = **left; {
+                    assert_eq!(*loop_var, "catch".into());
+                });
+
+                assert_let!(Expr { node: ExprKind::If(ref if_expr, _, _), .. } = **right; {
+                    assert_let!(Expr { node: ExprKind::Path(None, ref if_var), .. } = **if_expr; {
+                        assert_eq!(*if_var, "catch".into());
+                    });
+                });
+            });
+        });
+
+        assert_let!(Stmt::Semi(ref expr) = body.stmts[7]; {
+            assert_let!(Expr { node: ExprKind::Match(ref match_expr, _), .. } = **expr; {
+                assert_let!(Expr { node: ExprKind::Path(None, ref match_var), .. } = **match_expr; {
+                    assert_eq!(*match_var, "catch".into());
+                });
+            });
+        });
+    });
+}
diff --git a/tests/test_round_trip.rs b/tests/test_round_trip.rs
index b1560db..f2a1ba8 100644
--- a/tests/test_round_trip.rs
+++ b/tests/test_round_trip.rs
@@ -74,8 +74,6 @@
         "tests/rust/src/test/pretty/stmt_expr_attributes.rs" |
         // not actually a test case
         "tests/rust/src/test/run-pass/auxiliary/macro-include-items-expr.rs" |
-        // TODO catch expressions
-        "tests/rust/src/test/run-pass/catch-expr.rs" |
         // TODO better support for attributes
         "tests/rust/src/test/run-pass/cfg_stmt_expr.rs" |
         // TODO 128-bit integer literals