Upgrade rust/crates/pin-project to 1.0.1

* Add missing patches, needed by external_updater

Test: make
Test: tools/external_updater/updater.sh update --refresh --keep_date rust/crates/pin-project
Change-Id: I3738561830ce97903036460713eb3b74700b889e

1 files changed, 85 insertions, 115 deletions

diff --git a/tests/pinned_drop.rs b/tests/pinned_drop.rs
index e257758..e369ecb 100644
--- a/tests/pinned_drop.rs
+++ b/tests/pinned_drop.rs
@@ -25,62 +25,9 @@ fn safe_project() {
 }
 
 #[test]
-fn self_argument_in_macro() {
-    use pin_project::{pin_project, pinned_drop};
-    use std::pin::Pin;
-
-    #[pin_project(PinnedDrop)]
-    struct Struct {
-        x: (),
-    }
-
-    #[pinned_drop]
-    impl PinnedDrop for Struct {
-        fn drop(self: Pin<&mut Self>) {
-            let _: Vec<_> = vec![self.x];
-        }
-    }
-}
-
-#[test]
-fn self_in_macro_containing_fn() {
-    use pin_project::{pin_project, pinned_drop};
-    use std::pin::Pin;
-
-    macro_rules! mac {
-        ($($tt:tt)*) => {
-            $($tt)*
-        };
-    }
-
-    #[pin_project(PinnedDrop)]
-    pub struct Struct {
-        _x: (),
-    }
-
-    #[pinned_drop]
-    impl PinnedDrop for Struct {
-        fn drop(self: Pin<&mut Self>) {
-            let _ = mac!({
-                impl Struct {
-                    pub fn _f(self) -> Self {
-                        self
-                    }
-                }
-            });
-        }
-    }
-}
-
-#[test]
 fn self_call() {
-    use pin_project::{pin_project, pinned_drop};
-    use std::pin::Pin;
-
     #[pin_project(PinnedDrop)]
-    pub struct Struct<T> {
-        _x: T,
-    }
+    pub struct S<T>(T);
 
     trait Trait {
         fn self_ref(&self) {}
@@ -90,10 +37,10 @@ fn self_call() {
         fn assoc_fn(_this: Pin<&mut Self>) {}
     }
 
-    impl<T> Trait for Struct<T> {}
+    impl<T> Trait for S<T> {}
 
     #[pinned_drop]
-    impl<T> PinnedDrop for Struct<T> {
+    impl<T> PinnedDrop for S<T> {
         fn drop(mut self: Pin<&mut Self>) {
             self.self_ref();
             self.as_ref().self_pin_ref();
@@ -106,13 +53,10 @@ fn self_call() {
 }
 
 #[test]
-fn self_struct() {
-    use pin_project::{pin_project, pinned_drop};
-    use std::pin::Pin;
-
+fn self_ty() {
     #[pin_project(PinnedDrop)]
     pub struct Struct {
-        pub x: (),
+        pub f: (),
     }
 
     #[pinned_drop]
@@ -121,14 +65,14 @@ fn self_struct() {
         #[allow(clippy::match_single_binding)]
         fn drop(mut self: Pin<&mut Self>) {
             // expr
-            let _: Self = Self { x: () };
+            let _: Self = Self { f: () };
 
             // pat
             match *self {
-                Self { x: _ } => {}
+                Self { f: _ } => {}
             }
-            if let Self { x: _ } = *self {}
-            let Self { x: _ } = *self;
+            if let Self { f: _ } = *self {}
+            let Self { f: _ } = *self;
         }
     }
 
@@ -150,56 +94,74 @@ fn self_struct() {
             let Self(_) = *self;
         }
     }
-}
-
-#[rustversion::since(1.37)] // type_alias_enum_variants requires Rust 1.37
-#[test]
-fn self_enum() {
-    use pin_project::{pin_project, pinned_drop};
-    use std::pin::Pin;
 
-    #[pin_project(PinnedDrop)]
+    #[pin_project(PinnedDrop, project = EnumProj, project_ref = EnumProjRef)]
     pub enum Enum {
-        Struct { x: () },
+        Struct { f: () },
         Tuple(()),
+        Unit,
     }
 
     #[pinned_drop]
     impl PinnedDrop for Enum {
         fn drop(mut self: Pin<&mut Self>) {
             // expr
-            let _: Self = Self::Struct { x: () };
+            let _: Self = Self::Struct { f: () };
             let _: Self = Self::Tuple(());
+            let _: Self = Self::Unit;
 
             // pat
             match *self {
-                Self::Struct { x: _ } => {}
+                Self::Struct { f: _ } => {}
                 Self::Tuple(_) => {}
+                Self::Unit => {}
             }
-            if let Self::Struct { x: _ } = *self {}
+            if let Self::Struct { f: _ } = *self {}
             if let Self::Tuple(_) = *self {}
+            if let Self::Unit = *self {}
         }
     }
 }
 
-// See also `ui/pinned_drop/self.rs`.
-#[rustversion::since(1.40)] // https://github.com/rust-lang/rust/pull/64690
 #[test]
-fn self_in_macro_def() {
-    use pin_project::{pin_project, pinned_drop};
-    use std::pin::Pin;
+fn self_inside_macro_containing_fn() {
+    macro_rules! mac {
+        ($($tt:tt)*) => {
+            $($tt)*
+        };
+    }
 
     #[pin_project(PinnedDrop)]
-    pub struct Struct {
-        _x: (),
+    pub struct S(());
+
+    #[pinned_drop]
+    impl PinnedDrop for S {
+        fn drop(self: Pin<&mut Self>) {
+            let _ = mac!({
+                impl S {
+                    pub fn _f(self) -> Self {
+                        self
+                    }
+                }
+            });
+        }
     }
+}
+
+// See also `ui/pinned_drop/self.rs`.
+#[rustversion::since(1.40)] // https://github.com/rust-lang/rust/pull/64690
+#[test]
+fn self_inside_macro_def() {
+    #[pin_project(PinnedDrop)]
+    pub struct S(());
 
     #[pinned_drop]
-    impl PinnedDrop for Struct {
+    impl PinnedDrop for S {
         fn drop(self: Pin<&mut Self>) {
             macro_rules! mac {
                 () => {{
                     let _ = self;
+                    let _ = Self(());
                 }};
             }
             mac!();
@@ -208,10 +170,22 @@ fn self_in_macro_def() {
 }
 
 #[test]
-fn self_inside_macro() {
-    use pin_project::{pin_project, pinned_drop};
-    use std::pin::Pin;
+fn self_arg_inside_macro_call() {
+    #[pin_project(PinnedDrop)]
+    struct Struct {
+        f: (),
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for Struct {
+        fn drop(self: Pin<&mut Self>) {
+            let _: Vec<_> = vec![self.f];
+        }
+    }
+}
 
+#[test]
+fn self_ty_inside_macro_call() {
     macro_rules! mac {
         ($($tt:tt)*) => {
             $($tt)*
@@ -223,24 +197,24 @@ fn self_inside_macro() {
     where
         mac!(Self): Send,
     {
-        _x: T,
+        _f: T,
     }
 
     impl<T: Send> Struct<T> {
-        const ASSOCIATED1: &'static str = "1";
-        fn associated1() {}
+        const ASSOC1: &'static str = "1";
+        fn assoc1() {}
     }
 
     trait Trait {
-        type Associated2;
-        const ASSOCIATED2: &'static str;
-        fn associated2();
+        type Assoc2;
+        const ASSOC2: &'static str;
+        fn assoc2();
     }
 
     impl<T: Send> Trait for Struct<T> {
-        type Associated2 = ();
-        const ASSOCIATED2: &'static str = "2";
-        fn associated2() {}
+        type Assoc2 = ();
+        const ASSOC2: &'static str = "2";
+        fn assoc2() {}
     }
 
     #[pinned_drop]
@@ -252,38 +226,34 @@ fn self_inside_macro() {
         #[allow(clippy::no_effect)]
         fn drop(self: Pin<&mut Self>) {
             // inherent items
-            mac!(Self::ASSOCIATED1;);
-            mac!(<Self>::ASSOCIATED1;);
-            mac!(Self::associated1(););
-            mac!(<Self>::associated1(););
+            mac!(Self::ASSOC1;);
+            mac!(<Self>::ASSOC1;);
+            mac!(Self::assoc1(););
+            mac!(<Self>::assoc1(););
 
             // trait items
-            mac!(let _: <Self as Trait>::Associated2;);
-            mac!(Self::ASSOCIATED2;);
-            mac!(<Self>::ASSOCIATED2;);
-            mac!(<Self as Trait>::ASSOCIATED2;);
-            mac!(Self::associated2(););
-            mac!(<Self>::associated2(););
-            mac!(<Self as Trait>::associated2(););
+            mac!(let _: <Self as Trait>::Assoc2;);
+            mac!(Self::ASSOC2;);
+            mac!(<Self>::ASSOC2;);
+            mac!(<Self as Trait>::ASSOC2;);
+            mac!(Self::assoc2(););
+            mac!(<Self>::assoc2(););
+            mac!(<Self as Trait>::assoc2(););
         }
     }
 }
 
 #[test]
 fn inside_macro() {
-    use pin_project::{pin_project, pinned_drop};
-    use std::pin::Pin;
-
     #[pin_project(PinnedDrop)]
-    struct Struct(());
+    struct S(());
 
     macro_rules! mac {
         ($expr:expr) => {
             #[pinned_drop]
-            impl PinnedDrop for Struct {
-                #[allow(clippy::no_effect)]
+            impl PinnedDrop for S {
                 fn drop(self: Pin<&mut Self>) {
-                    $expr;
+                    let _ = $expr;
                 }
             }
         };