Upgrade rust/crates/pin-project to 0.4.22android-r-beta-3android-r-beta-2

* Keep local change in src/lib.rs

Test: make
Change-Id: I63ca4a3f247df2028bcb6cb849823b296865f444

1 files changed, 144 insertions, 86 deletions

diff --git a/tests/pinned_drop.rs b/tests/pinned_drop.rs
index b0677e2..e257758 100644
--- a/tests/pinned_drop.rs
+++ b/tests/pinned_drop.rs
@@ -1,5 +1,4 @@
 #![warn(rust_2018_idioms, single_use_lifetimes)]
-#![allow(dead_code)]
 
 use pin_project::{pin_project, pinned_drop};
 use std::pin::Pin;
@@ -26,66 +25,61 @@ fn safe_project() {
 }
 
 #[test]
-fn mut_self_argument() {
-    #[pin_project(PinnedDrop)]
-    struct Struct {
-        data: usize,
-    }
-
-    #[pinned_drop]
-    impl PinnedDrop for Struct {
-        fn drop(mut self: Pin<&mut Self>) {
-            let _: &mut _ = &mut self.data;
-        }
-    }
-}
+fn self_argument_in_macro() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
 
-#[test]
-fn self_in_vec() {
     #[pin_project(PinnedDrop)]
     struct Struct {
-        data: usize,
+        x: (),
     }
 
     #[pinned_drop]
     impl PinnedDrop for Struct {
         fn drop(self: Pin<&mut Self>) {
-            let _: Vec<_> = vec![self.data];
+            let _: Vec<_> = vec![self.x];
         }
     }
 }
 
 #[test]
 fn self_in_macro_containing_fn() {
-    #[pin_project(PinnedDrop)]
-    pub struct Struct {
-        data: usize,
-    }
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
 
-    macro_rules! emit {
+    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 _ = emit!({
+            let _ = mac!({
                 impl Struct {
-                    pub fn f(self) {}
+                    pub fn _f(self) -> Self {
+                        self
+                    }
                 }
             });
-            let _ = self.data;
         }
     }
 }
 
 #[test]
 fn self_call() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
     #[pin_project(PinnedDrop)]
-    pub struct Struct {
-        data: usize,
+    pub struct Struct<T> {
+        _x: T,
     }
 
     trait Trait {
@@ -96,10 +90,10 @@ fn self_call() {
         fn assoc_fn(_this: Pin<&mut Self>) {}
     }
 
-    impl Trait for Struct {}
+    impl<T> Trait for Struct<T> {}
 
     #[pinned_drop]
-    impl PinnedDrop for Struct {
+    impl<T> PinnedDrop for Struct<T> {
         fn drop(mut self: Pin<&mut Self>) {
             self.self_ref();
             self.as_ref().self_pin_ref();
@@ -112,53 +106,13 @@ fn self_call() {
 }
 
 #[test]
-fn self_expr() {
-    #[pin_project(PinnedDrop)]
-    pub struct Struct {
-        x: usize,
-    }
-
-    #[pinned_drop]
-    impl PinnedDrop for Struct {
-        fn drop(mut self: Pin<&mut Self>) {
-            let _: Self = Self { x: 0 };
-        }
-    }
-
-    #[pin_project(PinnedDrop)]
-    pub struct TupleStruct(usize);
-
-    #[pinned_drop]
-    impl PinnedDrop for TupleStruct {
-        fn drop(mut self: Pin<&mut Self>) {
-            let _: Self = Self(0);
-        }
-    }
-}
-
-#[rustversion::since(1.37)]
-#[test]
-fn self_expr_enum() {
-    #[pin_project(PinnedDrop)]
-    pub enum Enum {
-        StructVariant { x: usize },
-        TupleVariant(usize),
-    }
-
-    #[pinned_drop]
-    impl PinnedDrop for Enum {
-        fn drop(mut self: Pin<&mut Self>) {
-            let _: Self = Self::StructVariant { x: 0 };
-            let _: Self = Self::TupleVariant(0);
-        }
-    }
-}
+fn self_struct() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
 
-#[test]
-fn self_pat() {
     #[pin_project(PinnedDrop)]
     pub struct Struct {
-        x: usize,
+        pub x: (),
     }
 
     #[pinned_drop]
@@ -166,6 +120,10 @@ fn self_pat() {
         #[allow(irrefutable_let_patterns)]
         #[allow(clippy::match_single_binding)]
         fn drop(mut self: Pin<&mut Self>) {
+            // expr
+            let _: Self = Self { x: () };
+
+            // pat
             match *self {
                 Self { x: _ } => {}
             }
@@ -175,12 +133,16 @@ fn self_pat() {
     }
 
     #[pin_project(PinnedDrop)]
-    pub struct TupleStruct(usize);
+    pub struct TupleStruct(());
 
     #[pinned_drop]
     impl PinnedDrop for TupleStruct {
         #[allow(irrefutable_let_patterns)]
         fn drop(mut self: Pin<&mut Self>) {
+            // expr
+            let _: Self = Self(());
+
+            // pat
             match *self {
                 Self(_) => {}
             }
@@ -190,24 +152,32 @@ fn self_pat() {
     }
 }
 
-#[rustversion::since(1.37)]
+#[rustversion::since(1.37)] // type_alias_enum_variants requires Rust 1.37
 #[test]
-fn self_pat_enum() {
+fn self_enum() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
     #[pin_project(PinnedDrop)]
     pub enum Enum {
-        StructVariant { x: usize },
-        TupleVariant(usize),
+        Struct { x: () },
+        Tuple(()),
     }
 
     #[pinned_drop]
     impl PinnedDrop for Enum {
         fn drop(mut self: Pin<&mut Self>) {
+            // expr
+            let _: Self = Self::Struct { x: () };
+            let _: Self = Self::Tuple(());
+
+            // pat
             match *self {
-                Self::StructVariant { x: _ } => {}
-                Self::TupleVariant(_) => {}
+                Self::Struct { x: _ } => {}
+                Self::Tuple(_) => {}
             }
-            if let Self::StructVariant { x: _ } = *self {}
-            if let Self::TupleVariant(_) = *self {}
+            if let Self::Struct { x: _ } = *self {}
+            if let Self::Tuple(_) = *self {}
         }
     }
 }
@@ -216,20 +186,108 @@ fn self_pat_enum() {
 #[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;
+
     #[pin_project(PinnedDrop)]
     pub struct Struct {
-        x: usize,
+        _x: (),
     }
 
     #[pinned_drop]
     impl PinnedDrop for Struct {
         fn drop(self: Pin<&mut Self>) {
-            macro_rules! t {
+            macro_rules! mac {
                 () => {{
                     let _ = self;
                 }};
             }
-            t!();
+            mac!();
+        }
+    }
+}
+
+#[test]
+fn self_inside_macro() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
+    macro_rules! mac {
+        ($($tt:tt)*) => {
+            $($tt)*
+        };
+    }
+
+    #[pin_project(PinnedDrop)]
+    pub struct Struct<T: Send>
+    where
+        mac!(Self): Send,
+    {
+        _x: T,
+    }
+
+    impl<T: Send> Struct<T> {
+        const ASSOCIATED1: &'static str = "1";
+        fn associated1() {}
+    }
+
+    trait Trait {
+        type Associated2;
+        const ASSOCIATED2: &'static str;
+        fn associated2();
+    }
+
+    impl<T: Send> Trait for Struct<T> {
+        type Associated2 = ();
+        const ASSOCIATED2: &'static str = "2";
+        fn associated2() {}
+    }
+
+    #[pinned_drop]
+    impl<T: Send> PinnedDrop for Struct<T>
+    where
+        mac!(Self): Send,
+    {
+        #[allow(path_statements)]
+        #[allow(clippy::no_effect)]
+        fn drop(self: Pin<&mut Self>) {
+            // inherent items
+            mac!(Self::ASSOCIATED1;);
+            mac!(<Self>::ASSOCIATED1;);
+            mac!(Self::associated1(););
+            mac!(<Self>::associated1(););
+
+            // 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(););
         }
     }
 }
+
+#[test]
+fn inside_macro() {
+    use pin_project::{pin_project, pinned_drop};
+    use std::pin::Pin;
+
+    #[pin_project(PinnedDrop)]
+    struct Struct(());
+
+    macro_rules! mac {
+        ($expr:expr) => {
+            #[pinned_drop]
+            impl PinnedDrop for Struct {
+                #[allow(clippy::no_effect)]
+                fn drop(self: Pin<&mut Self>) {
+                    $expr;
+                }
+            }
+        };
+    }
+
+    mac!(1);
+}