Switch x? desugaring to use QuestionMark trait and Try enum

Author: bluss

src/libcore/ops.rs

@@ -2813,24 +2813,29 @@ pub trait BoxPlace<Data: ?Sized> : Place<Data> {
 /// should not rely on any implementations of `Carrier` other than `Result`,
 /// i.e., you should not expect `?` to continue to work with `Option`, etc.
 #[unstable(feature = "question_mark_carrier", issue = "31436")]
+#[cfg_attr(not(stage0), rustc_deprecated(since = "", reason = "replaced by `QuestionMark`"))]
 pub trait Carrier {
     /// The type of the value when computation succeeds.
     type Success;
     /// The type of the value when computation errors out.
     type Error;
 
     /// Create a `Carrier` from a success value.
+    #[allow(deprecated)]
     fn from_success(Self::Success) -> Self;
 
     /// Create a `Carrier` from an error value.
+    #[allow(deprecated)]
     fn from_error(Self::Error) -> Self;
 
     /// Translate this `Carrier` to another implementation of `Carrier` with the
     /// same associated types.
+    #[allow(deprecated)]
     fn translate<T>(self) -> T where T: Carrier<Success=Self::Success, Error=Self::Error>;
 }
 
 #[unstable(feature = "question_mark_carrier", issue = "31436")]
+#[allow(deprecated)]
 impl<U, V> Carrier for Result<U, V> {
     type Success = U;
     type Error = V;
@@ -2843,6 +2848,7 @@ impl<U, V> Carrier for Result<U, V> {
         Err(e)
     }
 
+    #[allow(deprecated)]
     fn translate<T>(self) -> T
         where T: Carrier<Success=U, Error=V>
     {
@@ -2855,6 +2861,7 @@ impl<U, V> Carrier for Result<U, V> {
 
 struct _DummyErrorType;
 
+#[allow(deprecated)]
 impl Carrier for _DummyErrorType {
     type Success = ();
     type Error = ();
@@ -2867,9 +2874,55 @@ impl Carrier for _DummyErrorType {
         _DummyErrorType
     }
 
+    #[allow(deprecated)]
     fn translate<T>(self) -> T
         where T: Carrier<Success=(), Error=()>
     {
         T::from_success(())
     }
 }
+
+/// The `QuestionMark` trait is used to specify the functionality of `?`.
+///
+#[cfg(not(stage0))]
+#[unstable(feature = "question_mark_qm", issue = "31436")]
+pub trait QuestionMark<Done> {
+    ///
+    type Continue;
+    ///
+    fn question_mark(self) -> Try<Self::Continue, Done>;
+}
+
+/// The `Try` enum.
+#[cfg(not(stage0))]
+#[unstable(feature = "question_mark_try", issue = "31436")]
+#[derive(Debug, Copy, Clone)]
+pub enum Try<T, E> {
+    ///
+    Continue(T),
+    ///
+    Done(E),
+}
+
+#[cfg(not(stage0))]
+#[unstable(feature = "question_mark_impl", issue = "31436")]
+impl<T, U, E, F> QuestionMark<Result<U, F>> for Result<T, E>
+    where E: Into<F>
+{
+    type Continue = T;
+    fn question_mark(self) -> Try<T, Result<U, F>> {
+        match self {
+            Ok(x) => Try::Continue(x),
+            Err(e) => Try::Done(Err(e.into())),
+        }
+    }
+}
+
+#[cfg(not(stage0))]
+impl QuestionMark<_DummyErrorType> for _DummyErrorType
+{
+    type Continue = Self;
+    fn question_mark(self) -> Try<Self, Self> {
+        Try::Continue(self)
+    }
+}

src/librustc/hir/lowering.rs

@@ -1762,56 +1762,48 @@ impl<'a> LoweringContext<'a> {
                 ExprKind::Try(ref sub_expr) => {
                     // to:
                     //
+                    // match QuestionMark::question_mark(<expr>) {
+                    //     Try::Continue(val) => val,
+                    //     Try::Done(r) => return r,
+                    // }
                     // match Carrier::translate(<expr>) {
                     //     Ok(val) => val,
                     //     Err(err) => return Carrier::from_error(From::from(err))
                     // }
                     let unstable_span = self.allow_internal_unstable("?", e.span);
 
-                    // Carrier::translate(<expr>)
+                    // QuestionMark::question_mark(<expr>)
                     let discr = {
                         // expand <expr>
                         let sub_expr = self.lower_expr(sub_expr);
 
-                        let path = &["ops", "Carrier", "translate"];
+                        let path = &["ops", "QuestionMark", "question_mark"];
                         let path = P(self.expr_std_path(unstable_span, path, ThinVec::new()));
                         P(self.expr_call(e.span, path, hir_vec![sub_expr]))
                     };
 
-                    // Ok(val) => val
+                    // Continue(val) => val
                     let ok_arm = {
                         let val_ident = self.str_to_ident("val");
-                        let val_pat = self.pat_ident(e.span, val_ident);
-                        let val_expr = P(self.expr_ident(e.span, val_ident, val_pat.id));
-                        let ok_pat = self.pat_ok(e.span, val_pat);
+                        let val_pat = self.pat_ident(unstable_span, val_ident);
+                        let val_expr = P(self.expr_ident(unstable_span, val_ident, val_pat.id));
+                        let ok_pat = self.pat_continue(unstable_span, val_pat);
 
                         self.arm(hir_vec![ok_pat], val_expr)
                     };
 
-                    // Err(err) => return Carrier::from_error(From::from(err))
+                    // Done(r) => return r
                     let err_arm = {
                         let err_ident = self.str_to_ident("err");
-                        let err_local = self.pat_ident(e.span, err_ident);
-                        let from_expr = {
-                            let path = &["convert", "From", "from"];
-                            let from = P(self.expr_std_path(e.span, path, ThinVec::new()));
-                            let err_expr = self.expr_ident(e.span, err_ident, err_local.id);
-
-                            self.expr_call(e.span, from, hir_vec![err_expr])
-                        };
-                        let from_err_expr = {
-                            let path = &["ops", "Carrier", "from_error"];
-                            let from_err = P(self.expr_std_path(unstable_span, path,
-                                                                ThinVec::new()));
-                            P(self.expr_call(e.span, from_err, hir_vec![from_expr]))
-                        };
+                        let err_local = self.pat_ident(unstable_span, err_ident);
 
-                        let ret_expr = P(self.expr(e.span,
-                                                   hir::Expr_::ExprRet(Some(from_err_expr)),
+                        let err_expr = self.expr_ident(unstable_span, err_ident, err_local.id);
+                        let ret_expr = P(self.expr(unstable_span,
+                                                   hir::Expr_::ExprRet(Some(P(err_expr))),
                                                                        ThinVec::new()));
 
-                        let err_pat = self.pat_err(e.span, err_local);
-                        self.arm(hir_vec![err_pat], ret_expr)
+                        let done_pat = self.pat_done(unstable_span, err_local);
+                        self.arm(hir_vec![done_pat], ret_expr)
                     };
 
                     return self.expr_match(e.span, discr, hir_vec![err_arm, ok_arm],
@@ -2060,14 +2052,6 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn pat_ok(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
-        self.pat_std_enum(span, &["result", "Result", "Ok"], hir_vec![pat])
-    }
-
-    fn pat_err(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
-        self.pat_std_enum(span, &["result", "Result", "Err"], hir_vec![pat])
-    }
-
     fn pat_some(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
         self.pat_std_enum(span, &["option", "Option", "Some"], hir_vec![pat])
     }
@@ -2076,6 +2060,14 @@ impl<'a> LoweringContext<'a> {
         self.pat_std_enum(span, &["option", "Option", "None"], hir_vec![])
     }
 
+    fn pat_continue(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
+        self.pat_std_enum(span, &["ops", "Try", "Continue"], hir_vec![pat])
+    }
+
+    fn pat_done(&mut self, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
+        self.pat_std_enum(span, &["ops", "Try", "Done"], hir_vec![pat])
+    }
+
     fn pat_std_enum(&mut self,
                     span: Span,
                     components: &[&str],