added deref_mut_* versions of inner_deref methods as per discussion #50264

Author: Xandkeeper

src/libcore/option.rs

@@ -136,7 +136,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use iter::{FromIterator, FusedIterator, TrustedLen};
-use {hint, mem, ops::{self, Deref}};
+use {hint, mem, ops::{self, Deref, DerefMut}};
 use pin::Pin;
 
 // Note that this is not a lang item per se, but it has a hidden dependency on
@@ -1000,6 +1000,17 @@ impl<T: Deref> Option<T> {
     }
 }
 
+#[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
+impl<T: DerefMut> Option<T> {
+    /// Converts from `Option<T>` (or `&mut Option<T>`) to `Option<&mut T::Target>`.
+    ///
+    /// Leaves the original `Option` in-place, creating a new one containing a mutable reference to
+    /// the inner type's `Deref::Target` type.
+    pub fn as_deref_mut(&mut self) -> Option<&mut T::Target> {
+        self.as_mut().map(|t| t.deref_mut())
+    }
+}
+
 impl<T, E> Option<Result<T, E>> {
     /// Transposes an `Option` of a `Result` into a `Result` of an `Option`.
     ///

src/libcore/result.rs

@@ -232,7 +232,7 @@
 
 use fmt;
 use iter::{FromIterator, FusedIterator, TrustedLen};
-use ops::{self, Deref};
+use ops::{self, Deref, DerefMut};
 
 /// `Result` is a type that represents either success ([`Ok`]) or failure ([`Err`]).
 ///
@@ -927,7 +927,7 @@ impl<T: Default, E> Result<T, E> {
 
 #[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
 impl<T: Deref, E> Result<T, E> {
-    /// Converts from `&Result<T, E>` (or `&Result<T, E>`) to `Result<&T::Target, &E>`.
+    /// Converts from `Result<T, E>` (or `&Result<T, E>`) to `Result<&T::Target, &E>`.
     ///
     /// Leaves the original `Result` in-place, creating a new one containing a reference to the
     /// `Ok` type's `Deref::Target` type.
@@ -938,7 +938,7 @@ impl<T: Deref, E> Result<T, E> {
 
 #[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
 impl<T, E: Deref> Result<T, E> {
-    /// Converts from `&Result<T, E>` (or `&Result<T, E>`) to `Result<&T, &E::Target>`.
+    /// Converts from `Result<T, E>` (or `&Result<T, E>`) to `Result<&T, &E::Target>`.
     ///
     /// Leaves the original `Result` in-place, creating a new one containing a reference to the
     /// `Err` type's `Deref::Target` type.
@@ -950,7 +950,7 @@ impl<T, E: Deref> Result<T, E> {
 
 #[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
 impl<T: Deref, E: Deref> Result<T, E> {
-    /// Converts from `&Result<T, E>` (or `&Result<T, E>`) to `Result<&T::Target, &E::Target>`.
+    /// Converts from `Result<T, E>` (or `&Result<T, E>`) to `Result<&T::Target, &E::Target>`.
     ///
     /// Leaves the original `Result` in-place, creating a new one containing a reference to both
     /// the `Ok` and `Err` types' `Deref::Target` types.
@@ -960,6 +960,42 @@ impl<T: Deref, E: Deref> Result<T, E> {
     }
 }
 
+#[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
+impl<T: DerefMut, E> Result<T, E> {
+    /// Converts from `Result<T, E>` (or `&mut Result<T, E>`) to `Result<&mut T::Target, &mut E>`.
+    ///
+    /// Leaves the original `Result` in-place, creating a new one containing a mutable reference to
+    /// the `Ok` type's `Deref::Target` type.
+    pub fn as_deref_mut_ok(&mut self) -> Result<&mut T::Target, &mut E> {
+        self.as_mut().map(|t| t.deref_mut())
+    }
+}
+
+#[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
+impl<T, E: DerefMut> Result<T, E> {
+    /// Converts from `Result<T, E>` (or `&mut Result<T, E>`) to `Result<&mut T, &mut E::Target>`.
+    ///
+    /// Leaves the original `Result` in-place, creating a new one containing a mutable reference to
+    /// the `Err` type's `Deref::Target` type.
+    pub fn as_deref_mut_err(&mut self) -> Result<&mut T, &mut E::Target>
+    {
+        self.as_mut().map_err(|e| e.deref_mut())
+    }
+}
+
+#[unstable(feature = "inner_deref", reason = "newly added", issue = "50264")]
+impl<T: DerefMut, E: DerefMut> Result<T, E> {
+    /// Converts from `Result<T, E>` (or `&mut Result<T, E>`) to
+    /// `Result<&mut T::Target, &mut E::Target>`.
+    ///
+    /// Leaves the original `Result` in-place, creating a new one containing a mutable reference to
+    /// both the `Ok` and `Err` types' `Deref::Target` types.
+    pub fn as_deref_mut(&mut self) -> Result<&mut T::Target, &mut E::Target>
+    {
+        self.as_mut().map(|t| t.deref_mut()).map_err(|e| e.deref_mut())
+    }
+}
+
 impl<T, E> Result<Option<T>, E> {
     /// Transposes a `Result` of an `Option` into an `Option` of a `Result`.
     ///

src/libcore/tests/option.rs

@@ -1,6 +1,8 @@
 use core::option::*;
 use core::mem;
 use core::clone::Clone;
+use core::array::FixedSizeArray;
+use core::ops::DerefMut;
 
 #[test]
 fn test_get_ptr() {
@@ -319,13 +321,31 @@ fn test_option_as_deref() {
     assert_eq!(ref_option.as_deref(), Some("a result"));
 
     let ref_option = &Some(vec![1, 2, 3, 4, 5]);
-    assert_eq!(ref_option.as_deref(), Some(&[1, 2, 3, 4, 5][..]));
+    assert_eq!(ref_option.as_deref(), Some([1, 2, 3, 4, 5].as_slice()));
 
     // None: &Option<T: Deref>>::None -> None
     let ref_option: &Option<&i32> = &None;
     assert_eq!(ref_option.as_deref(), None);
 }
 
+#[test]
+fn test_option_as_deref_mut() {
+    // Some: &mut Option<T: Deref>::Some(T) -> Option<&mut T::Deref::Target>::Some(&mut *T)
+    let mut val = 42;
+    let ref_option = &mut Some(&mut val);
+    assert_eq!(ref_option.as_deref_mut(), Some(&mut 42));
+
+    let ref_option = &mut Some(String::from("a result"));
+    assert_eq!(ref_option.as_deref_mut(), Some(String::from("a result").deref_mut()));
+
+    let ref_option = &mut Some(vec![1, 2, 3, 4, 5]);
+    assert_eq!(ref_option.as_deref_mut(), Some([1, 2, 3, 4, 5].as_mut_slice()));
+
+    // None: &mut Option<T: Deref>>::None -> None
+    let ref_option: &mut Option<&mut i32> = &mut None;
+    assert_eq!(ref_option.as_deref_mut(), None);
+}
+
 #[test]
 fn test_replace() {
     let mut x = Some(2);

src/libcore/tests/result.rs

@@ -1,4 +1,6 @@
 use core::option::*;
+use core::array::FixedSizeArray;
+use core::ops::DerefMut;
 
 fn op1() -> Result<isize, &'static str> { Ok(666) }
 fn op2() -> Result<isize, &'static str> { Err("sadface") }
@@ -237,7 +239,7 @@ fn test_result_as_deref() {
     assert_eq!(ref_ok.as_deref_ok(), expected_result);
 
     let ref_ok = &Result::Ok::<Vec<i32>, u32>(vec![1, 2, 3, 4, 5]);
-    let expected_result = Result::Ok::<&[i32], &u32>(&[1, 2, 3, 4, 5][..]);
+    let expected_result = Result::Ok::<&[i32], &u32>([1, 2, 3, 4, 5].as_slice());
     assert_eq!(ref_ok.as_deref_ok(), expected_result);
 
     // &Result<T: Deref, E: Deref>::Ok(T).as_deref() ->
@@ -251,7 +253,7 @@ fn test_result_as_deref() {
     assert_eq!(ref_ok.as_deref(), expected_result);
 
     let ref_ok = &Result::Ok::<Vec<i32>, &u32>(vec![1, 2, 3, 4, 5]);
-    let expected_result = Result::Ok::<&[i32], &u32>(&[1, 2, 3, 4, 5][..]);
+    let expected_result = Result::Ok::<&[i32], &u32>([1, 2, 3, 4, 5].as_slice());
     assert_eq!(ref_ok.as_deref(), expected_result);
 
     // &Result<T, E: Deref>::Err(T).as_deref_err() ->
@@ -265,7 +267,7 @@ fn test_result_as_deref() {
     assert_eq!(ref_err.as_deref_err(), expected_result);
 
     let ref_err = &Result::Err::<u32, Vec<i32>>(vec![5, 4, 3, 2, 1]);
-    let expected_result = Result::Err::<&u32, &[i32]>(&[5, 4, 3, 2, 1][..]);
+    let expected_result = Result::Err::<&u32, &[i32]>([5, 4, 3, 2, 1].as_slice());
     assert_eq!(ref_err.as_deref_err(), expected_result);
 
     // &Result<T: Deref, E: Deref>::Err(T).as_deref_err() ->
@@ -279,7 +281,7 @@ fn test_result_as_deref() {
     assert_eq!(ref_err.as_deref(), expected_result);
 
     let ref_err = &Result::Err::<&u32, Vec<i32>>(vec![5, 4, 3, 2, 1]);
-    let expected_result = Result::Err::<&u32, &[i32]>(&[5, 4, 3, 2, 1][..]);
+    let expected_result = Result::Err::<&u32, &[i32]>([5, 4, 3, 2, 1].as_slice());
     assert_eq!(ref_err.as_deref(), expected_result);
 
     // The following cases test calling `as_deref_*` with the wrong variant (i.e.
@@ -316,3 +318,122 @@ fn test_result_as_deref() {
     let expected_result = Result::Err::<&u32, &[i32; 5]>(&[5, 4, 3, 2, 1]);
     assert_eq!(ref_err.as_deref_ok(), expected_result);
 }
+
+#[test]
+fn test_result_as_deref_mut() {
+    // &mut Result<T: Deref, E>::Ok(T).as_deref_mut_ok() ->
+    //      Result<&mut T::Deref::Target, &mut E>::Ok(&mut *T)
+    let mut val = 42;
+    let mut expected_val = 42;
+    let mut_ok = &mut Result::Ok::<&mut i32, u8>(&mut val);
+    let expected_result = Result::Ok::<&mut i32, &mut u8>(&mut expected_val);
+    assert_eq!(mut_ok.as_deref_mut_ok(), expected_result);
+
+    let mut expected_string = String::from("a result");
+    let mut_ok = &mut Result::Ok::<String, u32>(expected_string.clone());
+    let expected_result = Result::Ok::<&mut str, &mut u32>(expected_string.deref_mut());
+    assert_eq!(mut_ok.as_deref_mut_ok(), expected_result);
+
+    let mut expected_vec = vec![1, 2, 3, 4, 5];
+    let mut_ok = &mut Result::Ok::<Vec<i32>, u32>(expected_vec.clone());
+    let expected_result = Result::Ok::<&mut [i32], &mut u32>(expected_vec.as_mut_slice());
+    assert_eq!(mut_ok.as_deref_mut_ok(), expected_result);
+
+    // &mut Result<T: Deref, E: Deref>::Ok(T).as_deref_mut() ->
+    //      Result<&mut T::Deref::Target, &mut E::Deref::Target>::Ok(&mut *T)
+    let mut val = 42;
+    let mut expected_val = 42;
+    let mut_ok = &mut Result::Ok::<&mut i32, &mut u8>(&mut val);
+    let expected_result = Result::Ok::<&mut i32, &mut u8>(&mut expected_val);
+    assert_eq!(mut_ok.as_deref_mut(), expected_result);
+
+    let mut expected_string = String::from("a result");
+    let mut_ok = &mut Result::Ok::<String, &mut u32>(expected_string.clone());
+    let expected_result = Result::Ok::<&mut str, &mut u32>(expected_string.deref_mut());
+    assert_eq!(mut_ok.as_deref_mut(), expected_result);
+
+    let mut expected_vec = vec![1, 2, 3, 4, 5];
+    let mut_ok = &mut Result::Ok::<Vec<i32>, &mut u32>(expected_vec.clone());
+    let expected_result = Result::Ok::<&mut [i32], &mut u32>(expected_vec.as_mut_slice());
+    assert_eq!(mut_ok.as_deref_mut(), expected_result);
+
+    // &mut Result<T, E: Deref>::Err(T).as_deref_mut_err() ->
+    //      Result<&mut T, &mut E::Deref::Target>::Err(&mut *E)
+    let mut val = 41;
+    let mut expected_val = 41;
+    let mut_err = &mut Result::Err::<u8, &mut i32>(&mut val);
+    let expected_result = Result::Err::<&mut u8, &mut i32>(&mut expected_val);
+    assert_eq!(mut_err.as_deref_mut_err(), expected_result);
+
+    let mut expected_string = String::from("an error");
+    let mut_err = &mut Result::Err::<u32, String>(expected_string.clone());
+    let expected_result = Result::Err::<&mut u32, &mut str>(expected_string.deref_mut());
+    assert_eq!(mut_err.as_deref_mut_err(), expected_result);
+
+    let mut expected_vec = vec![5, 4, 3, 2, 1];
+    let mut_err = &mut Result::Err::<u32, Vec<i32>>(expected_vec.clone());
+    let expected_result = Result::Err::<&mut u32, &mut [i32]>(expected_vec.as_mut_slice());
+    assert_eq!(mut_err.as_deref_mut_err(), expected_result);
+
+    // &mut Result<T: Deref, E: Deref>::Err(T).as_deref_mut_err() ->
+    //      Result<&mut T, &mut E::Deref::Target>::Err(&mut *E)
+    let mut val = 41;
+    let mut expected_val = 41;
+    let mut_err = &mut Result::Err::<&mut u8, &mut i32>(&mut val);
+    let expected_result = Result::Err::<&mut u8, &mut i32>(&mut expected_val);
+    assert_eq!(mut_err.as_deref_mut(), expected_result);
+
+    let mut expected_string = String::from("an error");
+    let mut_err = &mut Result::Err::<&mut u32, String>(expected_string.clone());
+    let expected_result = Result::Err::<&mut u32, &mut str>(expected_string.as_mut_str());
+    assert_eq!(mut_err.as_deref_mut(), expected_result);
+
+    let mut expected_vec = vec![5, 4, 3, 2, 1];
+    let mut_err = &mut Result::Err::<&mut u32, Vec<i32>>(expected_vec.clone());
+    let expected_result = Result::Err::<&mut u32, &mut [i32]>(expected_vec.as_mut_slice());
+    assert_eq!(mut_err.as_deref_mut(), expected_result);
+
+    // The following cases test calling `as_deref_mut_*` with the wrong variant (i.e.
+    // `as_deref_mut_ok()` with a `Result::Err()`, or `as_deref_mut_err()` with a `Result::Ok()`.
+    // While uncommon, these cases are supported to ensure that an `as_deref_mut_*`
+    // call can still be made even when one of the Result types does not implement
+    // `Deref` (for example, std::io::Error).
+
+    // &mut Result<T, E: Deref>::Ok(T).as_deref_mut_err() ->
+    //      Result<&mut T, &mut E::Deref::Target>::Ok(&mut T)
+    let mut expected_val = 42;
+    let mut_ok = &mut Result::Ok::<i32, &mut u8>(expected_val.clone());
+    let expected_result = Result::Ok::<&mut i32, &mut u8>(&mut expected_val);
+    assert_eq!(mut_ok.as_deref_mut_err(), expected_result);
+
+    let string = String::from("a result");
+    let expected_string = string.clone();
+    let mut ref_str = expected_string.as_ref();
+    let mut_ok = &mut Result::Ok::<&str, &mut u32>(string.as_str());
+    let expected_result = Result::Ok::<&mut &str, &mut u32>(&mut ref_str);
+    assert_eq!(mut_ok.as_deref_mut_err(), expected_result);
+
+    let mut expected_arr = [1, 2, 3, 4, 5];
+    let mut_ok = &mut Result::Ok::<[i32; 5], &mut u32>(expected_arr.clone());
+    let expected_result = Result::Ok::<&mut [i32; 5], &mut u32>(&mut expected_arr);
+    assert_eq!(mut_ok.as_deref_mut_err(), expected_result);
+
+    // &mut Result<T: Deref, E>::Err(E).as_deref_mut_ok() ->
+    //      Result<&mut T::Deref::Target, &mut E>::Err(&mut E)
+    let mut expected_val = 41;
+    let mut_err = &mut Result::Err::<&mut u8, i32>(expected_val.clone());
+    let expected_result = Result::Err::<&mut u8, &mut i32>(&mut expected_val);
+    assert_eq!(mut_err.as_deref_mut_ok(), expected_result);
+
+    let string = String::from("an error");
+    let expected_string = string.clone();
+    let mut ref_str = expected_string.as_ref();
+    let mut_err = &mut Result::Err::<&mut u32, &str>(string.as_str());
+    let expected_result = Result::Err::<&mut u32, &mut &str>(&mut ref_str);
+    assert_eq!(mut_err.as_deref_mut_ok(), expected_result);
+
+    let mut expected_arr = [5, 4, 3, 2, 1];
+    let mut_err = &mut Result::Err::<&mut u32, [i32; 5]>(expected_arr.clone());
+    let expected_result = Result::Err::<&mut u32, &mut [i32; 5]>(&mut expected_arr);
+    assert_eq!(mut_err.as_deref_mut_ok(), expected_result);
+}

src/test/ui/issues/issue-50264-inner-deref-trait/option-as_deref.stderr

@@ -2,7 +2,7 @@ error[E0599]: no method named `as_deref` found for type `std::option::Option<{in
   --> $DIR/option-as_deref.rs:4:29
    |
 LL |     let _result = &Some(42).as_deref();
-   |                             ^^^^^^^^
+   |                             ^^^^^^^^ help: did you mean: `as_ref`
    |
    = note: the method `as_deref` exists but the following trait bounds were not satisfied:
            `{integer} : std::ops::Deref`

src/test/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.rs

@@ -0,0 +1,6 @@
+#![feature(inner_deref)]
+
+fn main() {
+    let _result = &mut Some(42).as_deref_mut();
+//~^ ERROR no method named `as_deref_mut` found for type `std::option::Option<{integer}>`
+}

src/test/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.stderr

@@ -0,0 +1,12 @@
+error[E0599]: no method named `as_deref_mut` found for type `std::option::Option<{integer}>` in the current scope
+  --> $DIR/option-as_deref_mut.rs:4:33
+   |
+LL |     let _result = &mut Some(42).as_deref_mut();
+   |                                 ^^^^^^^^^^^^
+   |
+   = note: the method `as_deref_mut` exists but the following trait bounds were not satisfied:
+           `{integer} : std::ops::DerefMut`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0599`.

src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref.stderr

@@ -2,7 +2,7 @@ error[E0599]: no method named `as_deref` found for type `std::result::Result<{in
   --> $DIR/result-as_deref.rs:4:27
    |
 LL |     let _result = &Ok(42).as_deref();
-   |                           ^^^^^^^^
+   |                           ^^^^^^^^ help: did you mean: `as_ref`
    |
    = note: the method `as_deref` exists but the following trait bounds were not satisfied:
            `{integer} : std::ops::Deref`

src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_err.stderr

@@ -2,7 +2,7 @@ error[E0599]: no method named `as_deref_err` found for type `std::result::Result
   --> $DIR/result-as_deref_err.rs:4:28
    |
 LL |     let _result = &Err(41).as_deref_err();
-   |                            ^^^^^^^^^^^^
+   |                            ^^^^^^^^^^^^ help: did you mean: `as_deref_ok`
    |
    = note: the method `as_deref_err` exists but the following trait bounds were not satisfied:
            `{integer} : std::ops::Deref`

src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.rs

@@ -0,0 +1,6 @@
+#![feature(inner_deref)]
+
+fn main() {
+    let _result = &mut Ok(42).as_deref_mut();
+//~^ ERROR no method named `as_deref_mut` found
+}

src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr

@@ -0,0 +1,12 @@
+error[E0599]: no method named `as_deref_mut` found for type `std::result::Result<{integer}, _>` in the current scope
+  --> $DIR/result-as_deref_mut.rs:4:31
+   |
+LL |     let _result = &mut Ok(42).as_deref_mut();
+   |                               ^^^^^^^^^^^^ help: did you mean: `as_deref_err`
+   |
+   = note: the method `as_deref_mut` exists but the following trait bounds were not satisfied:
+           `{integer} : std::ops::DerefMut`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0599`.

src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut_err.rs

@@ -0,0 +1,6 @@
+#![feature(inner_deref)]
+
+fn main() {
+    let _result = &mut Err(41).as_deref_mut_err();
+//~^ ERROR no method named `as_deref_mut_err` found
+}