Expand try! to ? breaking change - DO NOT LAND!

Author: nrc

src/libcore/macros.rs

@@ -189,7 +189,6 @@ macro_rules! debug_assert_eq {
     ($($arg:tt)*) => (if cfg!(debug_assertions) { assert_eq!($($arg)*); })
 }
 
-/// Helper macro for unwrapping `Result` values while returning early with an
 /// error if the value of the expression is `Err`. Can only be used in
 /// functions that return `Result` because of the early return of `Err` that
 /// it provides.
@@ -218,6 +217,7 @@ macro_rules! debug_assert_eq {
 ///     Ok(())
 /// }
 /// ```
+#[cfg(stage0)]
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 macro_rules! try {
@@ -228,6 +228,13 @@ macro_rules! try {
         }
     })
 }
+/// Helper macro for unwrapping `Result` values while returning early with an
+#[cfg(not(stage0))]
+#[macro_export]
+#[stable(feature = "rust1", since = "1.0.0")]
+macro_rules! try {
+    ($expr:expr) => ($expr?)
+}
 
 /// Use the `format!` syntax to write data into a buffer.
 ///

src/librustc_const_eval/eval.rs

@@ -275,7 +275,7 @@ pub fn const_expr_to_pat<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         hir::ExprTup(ref exprs) =>
             PatKind::Tuple(try!(exprs.iter()
                                      .map(|expr| const_expr_to_pat(tcx, &expr, pat_id, span))
-                                     .collect()), None),
+                                     .collect::<Result<_, _>>()), None),
 
         hir::ExprCall(ref callee, ref args) => {
             let def = tcx.expect_def(callee.id);
@@ -295,7 +295,7 @@ pub fn const_expr_to_pat<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             let pats = try!(args.iter()
                                 .map(|expr| const_expr_to_pat(tcx, &**expr,
                                                               pat_id, span))
-                                .collect());
+                                .collect::<Result<_, _>>());
             PatKind::TupleStruct(path, pats, None)
         }
 
@@ -311,15 +311,15 @@ pub fn const_expr_to_pat<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                    is_shorthand: false,
                                },
                            }))
-                           .collect());
+                           .collect::<Result<_, _>>());
             PatKind::Struct(path.clone(), field_pats, false)
         }
 
         hir::ExprVec(ref exprs) => {
             let pats = try!(exprs.iter()
                                  .map(|expr| const_expr_to_pat(tcx, &expr,
                                                                pat_id, span))
-                                 .collect());
+                                 .collect::<Result<_, _>>());
             PatKind::Vec(pats, None, hir::HirVec::new())
         }
 

src/libsyntax/feature_gate.rs

@@ -261,12 +261,12 @@ declare_features! (
     // a...b and ...b
     (active, inclusive_range_syntax, "1.7.0", Some(28237)),
 
-    // `expr?`
-    (active, question_mark, "1.9.0", Some(31436)),
-
     // impl specialization (RFC 1210)
     (active, specialization, "1.7.0", Some(31844)),
 
+    // `expr?`
+    (active, question_mark, "1.9.0", Some(31436)),
+    
     // pub(restricted) visibilities (RFC 1422)
     (active, pub_restricted, "1.9.0", Some(32409)),
 
@@ -971,9 +971,6 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {
                                   e.span,
                                   "inclusive range syntax is experimental");
             }
-            ast::ExprKind::Try(..) => {
-                gate_feature_post!(&self, question_mark, e.span, "the `?` operator is not stable");
-            }
             ast::ExprKind::InPlace(..) => {
                 gate_feature_post!(&self, placement_in_syntax, e.span, EXPLAIN_PLACEMENT_IN);
             }