Add Drop::pin_drop for pinned drops

compiler/rustc_hir_analysis/messages.ftl

@@ -116,6 +116,11 @@ hir_analysis_coercion_between_struct_same_note = expected coercion between the s
 
 hir_analysis_coercion_between_struct_single_note = expected a single field to be coerced, none found
 
+hir_analysis_conflict_impl_drop_and_pin_drop = conflict implementation of `Drop::drop` and `Drop::pin_drop`
+    .drop_label = `drop(&mut self)` implemented here
+    .pin_drop_label = `pin_drop(&pin mut self)` implemented here
+    .suggestion = remove this implementation
+
 hir_analysis_const_bound_for_non_const_trait = `{$modifier}` can only be applied to `const` traits
     .label = can't be applied to `{$trait_name}`
     .note = `{$trait_name}` can't be used with `{$modifier}` because it isn't `const`
@@ -441,6 +446,13 @@ hir_analysis_paren_sugar_attribute = the `#[rustc_paren_sugar]` attribute is a t
 hir_analysis_parenthesized_fn_trait_expansion =
     parenthesized trait syntax expands to `{$expanded_type}`
 
+hir_analysis_pin_v2_without_pin_drop =
+    `{$adt_name}` must implement `pin_drop`
+    .note = `{$adt_name}` is marked `#[pin_v2]` here
+    .help = structurally pinned types must keep `Pin`'s safety contract
+    .pin_drop_sugg = implement `pin_drop` instead
+    .remove_pin_v2_sugg = remove the `#[pin_v2]` attribute if it is not intended for structurally pinning
+
 hir_analysis_placeholder_not_allowed_item_signatures = the placeholder `_` is not allowed within types on item signatures for {$kind}
     .label = not allowed in type signatures
 

compiler/rustc_hir_analysis/src/check/always_applicable.rs

@@ -7,11 +7,13 @@
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::codes::*;
 use rustc_errors::{ErrorGuaranteed, struct_span_code_err};
+use rustc_hir as hir;
 use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
 use rustc_infer::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::span_bug;
 use rustc_middle::ty::util::CheckRegions;
 use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt, TypingMode};
+use rustc_span::sym;
 use rustc_trait_selection::regions::InferCtxtRegionExt;
 use rustc_trait_selection::traits::{self, ObligationCtxt};
 
@@ -70,7 +72,11 @@ pub(crate) fn check_drop_impl(
                 drop_impl_did,
                 adt_def.did(),
                 adt_to_impl_args,
-            )
+            )?;
+
+            check_drop_xor_pin_drop(tcx, adt_def.did(), drop_impl_did)?;
+
+            Ok(())
         }
         _ => {
             span_bug!(tcx.def_span(drop_impl_did), "incoherent impl of Drop");
@@ -291,3 +297,68 @@ fn ensure_impl_predicates_are_implied_by_item_defn<'tcx>(
 
     Ok(())
 }
+
+/// This function checks at least and at most one of `Drop::drop` and `Drop::pin_drop` is implemented.
+/// It also checks that `Drop::pin_drop` must be implemented if `#[pin_v2]` is present on the type.
+fn check_drop_xor_pin_drop<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    adt_def_id: DefId,
+    drop_impl_did: LocalDefId,
+) -> Result<(), ErrorGuaranteed> {
+    let item_impl = tcx.hir_expect_item(drop_impl_did).expect_impl();
+    let mut drop_span = None;
+    let mut pin_drop_span = None;
+    for &impl_item_id in item_impl.items {
+        let impl_item = tcx.hir_impl_item(impl_item_id);
+        if let hir::ImplItemKind::Fn(fn_sig, _) = impl_item.kind {
+            match impl_item.ident.name {
+                sym::drop => drop_span = Some(fn_sig.span),
+                sym::pin_drop => pin_drop_span = Some(fn_sig.span),
+                _ => {}
+            }
+        }
+    }
+
+    match (drop_span, pin_drop_span) {
+        (None, None) => {
+            if tcx.features().pin_ergonomics() {
+                return Err(tcx.dcx().emit_err(crate::errors::MissingOneOfTraitItem {
+                    span: tcx.def_span(drop_impl_did),
+                    note: None,
+                    missing_items_msg: "drop`, `pin_drop".to_string(),
+                }));
+            } else {
+                return Err(tcx
+                    .dcx()
+                    .span_delayed_bug(tcx.def_span(drop_impl_did), "missing `Drop::drop`"));
+            }
+        }
+        (Some(span), None) => {
+            if tcx.adt_def(adt_def_id).is_pin_project() {
+                let pin_v2_span = tcx.get_attr(adt_def_id, sym::pin_v2).map(|attr| attr.span());
+                let adt_name = tcx.item_name(adt_def_id);
+                return Err(tcx.dcx().emit_err(crate::errors::PinV2WithoutPinDrop {
+                    span,
+                    pin_v2_span,
+                    adt_name,
+                }));
+            }
+        }
+        (None, Some(span)) => {
+            if !tcx.features().pin_ergonomics() {
+                return Err(tcx.dcx().span_delayed_bug(
+                    span,
+                    "`Drop::pin_drop` should be guarded by the library feature gate",
+                ));
+            }
+        }
+        (Some(drop_span), Some(pin_drop_span)) => {
+            return Err(tcx.dcx().emit_err(crate::errors::ConflictImplDropAndPinDrop {
+                span: tcx.def_span(drop_impl_did),
+                drop_span,
+                pin_drop_span,
+            }));
+        }
+    }
+    Ok(())
+}

compiler/rustc_hir_analysis/src/check/check.rs

@@ -24,6 +24,7 @@ use rustc_middle::ty::{
     TypeVisitable, TypeVisitableExt, fold_regions,
 };
 use rustc_session::lint::builtin::UNINHABITED_STATIC;
+use rustc_span::sym;
 use rustc_target::spec::{AbiMap, AbiMapping};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::error_reporting::traits::on_unimplemented::OnUnimplementedDirective;

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -92,7 +92,7 @@ use rustc_middle::ty::{
 use rustc_middle::{bug, span_bug};
 use rustc_session::parse::feature_err;
 use rustc_span::def_id::CRATE_DEF_ID;
-use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Symbol, kw, sym};
+use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Symbol, kw};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::error_reporting::infer::ObligationCauseExt as _;
 use rustc_trait_selection::error_reporting::traits::suggestions::ReturnsVisitor;

compiler/rustc_hir_analysis/src/errors.rs

@@ -1718,3 +1718,31 @@ pub(crate) struct AsyncDropWithoutSyncDrop {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(hir_analysis_conflict_impl_drop_and_pin_drop)]
+pub(crate) struct ConflictImplDropAndPinDrop {
+    #[primary_span]
+    pub span: Span,
+    #[label(hir_analysis_drop_label)]
+    pub drop_span: Span,
+    #[label(hir_analysis_pin_drop_label)]
+    pub pin_drop_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(hir_analysis_pin_v2_without_pin_drop)]
+#[help]
+pub(crate) struct PinV2WithoutPinDrop {
+    #[primary_span]
+    #[suggestion(
+        hir_analysis_pin_drop_sugg,
+        code = "fn pin_drop(&pin mut self)",
+        applicability = "maybe-incorrect"
+    )]
+    pub span: Span,
+    #[note]
+    #[suggestion(hir_analysis_remove_pin_v2_sugg, code = "", applicability = "maybe-incorrect")]
+    pub pin_v2_span: Option<Span>,
+    pub adt_name: Symbol,
+}

compiler/rustc_hir_typeck/src/callee.rs

@@ -37,9 +37,13 @@ pub(crate) fn check_legal_trait_for_method_call(
     receiver: Option<Span>,
     expr_span: Span,
     trait_id: DefId,
-    _body_id: DefId,
+    body_id: DefId,
 ) -> Result<(), ErrorGuaranteed> {
-    if tcx.is_lang_item(trait_id, LangItem::Drop) {
+    if tcx.is_lang_item(trait_id, LangItem::Drop)
+        // Allow calling `Drop::pin_drop` in `Drop::drop`
+        && let Some(parent) = tcx.opt_parent(body_id)
+        && !tcx.is_lang_item(parent, LangItem::Drop)
+    {
         let sugg = if let Some(receiver) = receiver.filter(|s| !s.is_empty()) {
             errors::ExplicitDestructorCallSugg::Snippet {
                 lo: expr_span.shrink_to_lo(),

compiler/rustc_span/src/symbol.rs

@@ -1682,6 +1682,7 @@ symbols! {
         pic,
         pie,
         pin,
+        pin_drop,
         pin_ergonomics,
         pin_macro,
         pin_v2,

library/core/src/ops/drop.rs

@@ -1,3 +1,5 @@
+use crate::pin::Pin;
+
 /// Custom code within the destructor.
 ///
 /// When a value is no longer needed, Rust will run a "destructor" on that value.
@@ -237,5 +239,30 @@ pub const trait Drop {
     /// [`mem::drop`]: drop
     /// [`ptr::drop_in_place`]: crate::ptr::drop_in_place
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn drop(&mut self);
+    #[rustc_default_body_unstable(feature = "pin_ergonomics", issue = "130494")]
+    fn drop(&mut self) {
+        // SAFETY: `self` is pinned till after dropped.
+        Drop::pin_drop(unsafe { Pin::new_unchecked(self) })
+    }
+
+    /// Execute the destructor for this type, but different to [`Drop::drop`], it requires `self`
+    /// to be pinned.
+    ///
+    /// By implementing this method instead of [`Drop::drop`], the receiver type [`Pin<&mut Self>`]
+    /// makes sure that the value is pinned until it is deallocated (See [`std::pin` module docs] for
+    /// more details), which enables us to support field projections of `Self` type safely.
+    ///
+    /// For types that support pin-projection (i.e., marked with `#[pin_v2]`), this method must be used.
+    ///
+    /// For any type, at least and at most one of [`Drop::drop`] and [`Drop::pin_drop`] should be
+    /// implemented.
+    ///
+    /// See also [`Drop::drop`] for more details.
+    ///
+    /// [`Drop::drop`]: crate::ops::Drop::drop
+    /// [`Drop::pin_drop`]: crate::ops::Drop::pin_drop
+    /// [`Pin<&mut Self>`]: crate::pin::Pin
+    /// [`std::pin` module docs]: crate::pin
+    #[unstable(feature = "pin_ergonomics", issue = "130494")]
+    fn pin_drop(self: Pin<&mut Self>) {}
 }

tests/codegen-units/item-collection/drop-glue-eager.rs

@@ -10,6 +10,7 @@ struct StructWithDrop {
 
 impl Drop for StructWithDrop {
     //~ MONO_ITEM fn <StructWithDrop as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <StructWithDrop as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }
 
@@ -24,6 +25,7 @@ enum EnumWithDrop {
 
 impl Drop for EnumWithDrop {
     //~ MONO_ITEM fn <EnumWithDrop as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <EnumWithDrop as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }
 
@@ -34,6 +36,7 @@ enum EnumNoDrop {
 // We should be able to monomorphize drops for struct with lifetimes.
 impl<'a> Drop for StructWithDropAndLt<'a> {
     //~ MONO_ITEM fn <StructWithDropAndLt<'_> as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <StructWithDropAndLt<'_> as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }
 
@@ -52,5 +55,6 @@ struct StructWithLtAndPredicate<'a: 'a> {
 // We should be able to monomorphize drops for struct with lifetimes.
 impl<'a> Drop for StructWithLtAndPredicate<'a> {
     //~ MONO_ITEM fn <StructWithLtAndPredicate<'_> as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <StructWithLtAndPredicate<'_> as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }

tests/codegen-units/item-collection/drop_in_place_intrinsic.rs

@@ -9,6 +9,7 @@ struct StructWithDtor(u32);
 
 impl Drop for StructWithDtor {
     //~ MONO_ITEM fn <StructWithDtor as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <StructWithDtor as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }
 

tests/codegen-units/item-collection/generic-drop-glue.rs

@@ -39,6 +39,7 @@ struct NonGenericWithDrop(#[allow(dead_code)] i32);
 
 impl Drop for NonGenericWithDrop {
     //~ MONO_ITEM fn <NonGenericWithDrop as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <NonGenericWithDrop as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }
 

tests/codegen-units/item-collection/non-generic-closures.rs

@@ -74,5 +74,6 @@ struct PresentDrop;
 
 impl Drop for PresentDrop {
     //~ MONO_ITEM fn <PresentDrop as std::ops::Drop>::drop @@ non_generic_closures-cgu.0[External]
+    //~ MONO_ITEM fn <PresentDrop as std::ops::Drop>::pin_drop @@ non_generic_closures-cgu.0[External]
     fn drop(&mut self) {}
 }

tests/codegen-units/item-collection/non-generic-drop-glue.rs

@@ -11,6 +11,7 @@ struct StructWithDrop {
 
 impl Drop for StructWithDrop {
     //~ MONO_ITEM fn <StructWithDrop as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <StructWithDrop as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }
 
@@ -25,6 +26,7 @@ enum EnumWithDrop {
 
 impl Drop for EnumWithDrop {
     //~ MONO_ITEM fn <EnumWithDrop as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <EnumWithDrop as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }
 

tests/codegen-units/item-collection/transitive-drop-glue.rs

@@ -13,6 +13,7 @@ struct Leaf;
 
 impl Drop for Leaf {
     //~ MONO_ITEM fn <Leaf as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <Leaf as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }
 

tests/codegen-units/item-collection/tuple-drop-glue.rs

@@ -9,6 +9,7 @@ struct Dropped;
 
 impl Drop for Dropped {
     //~ MONO_ITEM fn <Dropped as std::ops::Drop>::drop
+    //~ MONO_ITEM fn <Dropped as std::ops::Drop>::pin_drop
     fn drop(&mut self) {}
 }
 

tests/ui/async-await/async-drop/unexpected-sort.stderr

@@ -13,10 +13,16 @@ LL |     type c = ();
 error[E0046]: not all trait items implemented, missing: `drop`
   --> $DIR/unexpected-sort.rs:9:1
    |
-LL | impl Drop for a {
-   | ^^^^^^^^^^^^^^^ missing `drop` in implementation
+LL | / impl Drop for a {
+LL | |     fn b() {}
+LL | | }
+   | |_^
    |
-   = help: implement the missing item: `fn drop(&mut self) { todo!() }`
+   = note: default implementation of `drop` is unstable
+   = note: use of unstable library feature `pin_ergonomics`
+   = note: see issue #130494 <https://github.com/rust-lang/rust/issues/130494> for more information
+   = help: add `#![feature(pin_ergonomics)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0046]: not all trait items implemented, missing: `drop`
   --> $DIR/unexpected-sort.rs:12:1

tests/ui/drop/missing-drop-method.stderr

@@ -2,9 +2,13 @@ error[E0046]: not all trait items implemented, missing: `drop`
   --> $DIR/missing-drop-method.rs:2:1
    |
 LL | impl Drop for DropNoMethod {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `drop` in implementation
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: implement the missing item: `fn drop(&mut self) { todo!() }`
+   = note: default implementation of `drop` is unstable
+   = note: use of unstable library feature `pin_ergonomics`
+   = note: see issue #130494 <https://github.com/rust-lang/rust/issues/130494> for more information
+   = help: add `#![feature(pin_ergonomics)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: aborting due to 1 previous error
 

tests/ui/drop/nonsense-drop-impl-issue-139278.stderr

@@ -7,10 +7,16 @@ LL |     const SPLOK: u32 = 0;
 error[E0046]: not all trait items implemented, missing: `drop`
   --> $DIR/nonsense-drop-impl-issue-139278.rs:4:1
    |
-LL | impl Drop for Foo {
-   | ^^^^^^^^^^^^^^^^^ missing `drop` in implementation
+LL | / impl Drop for Foo {
+LL | |     const SPLOK: u32 = 0;
+LL | | }
+   | |_^
    |
-   = help: implement the missing item: `fn drop(&mut self) { todo!() }`
+   = note: default implementation of `drop` is unstable
+   = note: use of unstable library feature `pin_ergonomics`
+   = note: see issue #130494 <https://github.com/rust-lang/rust/issues/130494> for more information
+   = help: add `#![feature(pin_ergonomics)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: aborting due to 2 previous errors
 

tests/ui/dropck/unconstrained_const_param_on_drop.stderr

@@ -14,9 +14,13 @@ error[E0046]: not all trait items implemented, missing: `drop`
   --> $DIR/unconstrained_const_param_on_drop.rs:3:1
    |
 LL | impl<const UNUSED: usize> Drop for Foo {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `drop` in implementation
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: implement the missing item: `fn drop(&mut self) { todo!() }`
+   = note: default implementation of `drop` is unstable
+   = note: use of unstable library feature `pin_ergonomics`
+   = note: see issue #130494 <https://github.com/rust-lang/rust/issues/130494> for more information
+   = help: add `#![feature(pin_ergonomics)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0207]: the const parameter `UNUSED` is not constrained by the impl trait, self type, or predicates
   --> $DIR/unconstrained_const_param_on_drop.rs:3:6