Rollup merge of #150935 - rperier:provide_diagnostic_on_move_for_smart_pointers, r=JonathanBrouwer

Introduce #[diagnostic::on_move(message)]

cc #149862

This is a first proposal. I have deliberately kept it simpler than `diagnostic::on_unimplemented`.

Few questions/remarks:

- Do I need to move the OnMoveDirective logic into a dedicated module perhaps ? let's say into compiler/rustc_borrowck/src/diagnostics/on_move.rs
- No problems to depend on crates like `rustc_ast` from the borrowck ?
- Notes are not supported yet. While message and label are very static , in the sense that they are emitted in the same way from the same place in the borrowck, it is not the case for the notes. It would make the code more complex. But, I can add support for notes if it does make sense.

Suggestions are welcomed !

Author: Zalathar

compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs

@@ -22,6 +22,7 @@ use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, MetaItem
 
 pub(crate) mod do_not_recommend;
 pub(crate) mod on_const;
+pub(crate) mod on_move;
 pub(crate) mod on_unimplemented;
 
 #[derive(Copy, Clone)]
@@ -32,6 +33,8 @@ pub(crate) enum Mode {
     DiagnosticOnUnimplemented,
     /// `#[diagnostic::on_const]`
     DiagnosticOnConst,
+    /// `#[diagnostic::on_move]`
+    DiagnosticOnMove,
 }
 
 fn merge_directives<S: Stage>(
@@ -113,6 +116,13 @@ fn parse_directive_items<'p, S: Stage>(
                         span,
                     );
                 }
+                Mode::DiagnosticOnMove => {
+                    cx.emit_lint(
+                        MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                        AttributeLintKind::MalformedOnMoveAttr { span },
+                        span,
+                    );
+                }
             }
             continue;
         }}
@@ -132,7 +142,7 @@ fn parse_directive_items<'p, S: Stage>(
                 Mode::RustcOnUnimplemented => {
                     cx.emit_err(NoValueInOnUnimplemented { span: item.span() });
                 }
-                Mode::DiagnosticOnUnimplemented |Mode::DiagnosticOnConst => {
+                Mode::DiagnosticOnUnimplemented |Mode::DiagnosticOnConst | Mode::DiagnosticOnMove => {
                     cx.emit_lint(
                         MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                         AttributeLintKind::IgnoredDiagnosticOption {

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_move.rs

@@ -0,0 +1,72 @@
+use rustc_feature::template;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::lints::AttributeLintKind;
+use rustc_session::lint::builtin::MALFORMED_DIAGNOSTIC_ATTRIBUTES;
+use rustc_span::sym;
+
+use crate::attributes::diagnostic::*;
+use crate::attributes::prelude::*;
+use crate::context::{AcceptContext, Stage};
+use crate::parser::ArgParser;
+use crate::target_checking::{ALL_TARGETS, AllowedTargets};
+
+#[derive(Default)]
+pub(crate) struct OnMoveParser {
+    span: Option<Span>,
+    directive: Option<(Span, Directive)>,
+}
+
+impl OnMoveParser {
+    fn parse<'sess, S: Stage>(
+        &mut self,
+        cx: &mut AcceptContext<'_, 'sess, S>,
+        args: &ArgParser,
+        mode: Mode,
+    ) {
+        if !cx.features().diagnostic_on_move() {
+            return;
+        }
+
+        let span = cx.attr_span;
+        self.span = Some(span);
+        let Some(list) = args.list() else {
+            cx.emit_lint(
+                MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                AttributeLintKind::MissingOptionsForOnMove,
+                span,
+            );
+            return;
+        };
+
+        if list.is_empty() {
+            cx.emit_lint(
+                MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                AttributeLintKind::OnMoveMalformedAttrExpectedLiteralOrDelimiter,
+                list.span,
+            );
+            return;
+        }
+
+        if let Some(directive) = parse_directive_items(cx, mode, list.mixed(), true) {
+            merge_directives(cx, &mut self.directive, (span, directive));
+        }
+    }
+}
+impl<S: Stage> AttributeParser<S> for OnMoveParser {
+    const ATTRIBUTES: AcceptMapping<Self, S> = &[(
+        &[sym::diagnostic, sym::on_move],
+        template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
+        |this, cx, args| {
+            this.parse(cx, args, Mode::DiagnosticOnMove);
+        },
+    )];
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+
+    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
+        if let Some(span) = self.span {
+            Some(AttributeKind::OnMove { span, directive: self.directive.map(|d| Box::new(d.1)) })
+        } else {
+            None
+        }
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -29,6 +29,7 @@ use crate::attributes::debugger::*;
 use crate::attributes::deprecation::*;
 use crate::attributes::diagnostic::do_not_recommend::*;
 use crate::attributes::diagnostic::on_const::*;
+use crate::attributes::diagnostic::on_move::*;
 use crate::attributes::diagnostic::on_unimplemented::*;
 use crate::attributes::doc::*;
 use crate::attributes::dummy::*;
@@ -149,6 +150,7 @@ attribute_parsers!(
         MacroUseParser,
         NakedParser,
         OnConstParser,
+        OnMoveParser,
         OnUnimplementedParser,
         RustcAlignParser,
         RustcAlignStaticParser,

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -324,18 +324,23 @@ impl<'infcx, 'tcx> crate::MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         verb: &str,
         optional_adverb_for_moved: &str,
         moved_path: Option<String>,
+        primary_message: Option<String>,
     ) -> Diag<'infcx> {
-        let moved_path = moved_path.map(|mp| format!(": `{mp}`")).unwrap_or_default();
+        if let Some(primary_message) = primary_message {
+            struct_span_code_err!(self.dcx(), use_span, E0382, "{}", primary_message)
+        } else {
+            let moved_path = moved_path.map(|mp| format!(": `{mp}`")).unwrap_or_default();
 
-        struct_span_code_err!(
-            self.dcx(),
-            use_span,
-            E0382,
-            "{} of {}moved value{}",
-            verb,
-            optional_adverb_for_moved,
-            moved_path,
-        )
+            struct_span_code_err!(
+                self.dcx(),
+                use_span,
+                E0382,
+                "{} of {}moved value{}",
+                verb,
+                optional_adverb_for_moved,
+                moved_path,
+            )
+        }
     }
 
     pub(crate) fn cannot_borrow_path_as_mutable_because(

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -6,12 +6,16 @@ use std::ops::ControlFlow;
 use either::Either;
 use hir::{ClosureKind, Path};
 use rustc_data_structures::fx::FxIndexSet;
+use rustc_data_structures::thin_vec::ThinVec;
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, Diag, MultiSpan, struct_span_code_err};
 use rustc_hir as hir;
+use rustc_hir::attrs::diagnostic::FormatArgs;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{Visitor, walk_block, walk_expr};
-use rustc_hir::{CoroutineDesugaring, CoroutineKind, CoroutineSource, LangItem, PatField};
+use rustc_hir::{
+    CoroutineDesugaring, CoroutineKind, CoroutineSource, LangItem, PatField, find_attr,
+};
 use rustc_middle::bug;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::{
@@ -138,6 +142,36 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             let partial_str = if is_partial_move { "partial " } else { "" };
             let partially_str = if is_partial_move { "partially " } else { "" };
 
+            let (on_move_message, on_move_label, on_move_notes) = if let ty::Adt(item_def, args) =
+                self.body.local_decls[moved_place.local].ty.kind()
+                && let Some(Some(directive)) = find_attr!(self.infcx.tcx, item_def.did(), OnMove { directive, .. }  => directive)
+            {
+                let item_name = self.infcx.tcx.item_name(item_def.did()).to_string();
+                let mut generic_args: Vec<_> = self
+                    .infcx
+                    .tcx
+                    .generics_of(item_def.did())
+                    .own_params
+                    .iter()
+                    .filter_map(|param| Some((param.name, args[param.index as usize].to_string())))
+                    .collect();
+                generic_args.push((kw::SelfUpper, item_name));
+
+                let args = FormatArgs {
+                    this: String::new(),
+                    trait_sugared: String::new(),
+                    item_context: "",
+                    generic_args,
+                };
+                (
+                    directive.message.as_ref().map(|e| e.1.format(&args)),
+                    directive.label.as_ref().map(|e| e.1.format(&args)),
+                    directive.notes.iter().map(|e| e.format(&args)).collect(),
+                )
+            } else {
+                (None, None, ThinVec::new())
+            };
+
             let mut err = self.cannot_act_on_moved_value(
                 span,
                 desired_action.as_noun(),
@@ -146,8 +180,13 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     moved_place,
                     DescribePlaceOpt { including_downcast: true, including_tuple_field: true },
                 ),
+                on_move_message,
             );
 
+            for note in on_move_notes {
+                err.note(note);
+            }
+
             let reinit_spans = maybe_reinitialized_locations
                 .iter()
                 .take(3)
@@ -275,12 +314,16 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             if needs_note {
                 if let Some(local) = place.as_local() {
                     let span = self.body.local_decls[local].source_info.span;
-                    err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
-                        is_partial_move,
-                        ty,
-                        place: &note_msg,
-                        span,
-                    });
+                    if let Some(on_move_label) = on_move_label {
+                        err.span_label(span, on_move_label);
+                    } else {
+                        err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
+                            is_partial_move,
+                            ty,
+                            place: &note_msg,
+                            span,
+                        });
+                    }
                 } else {
                     err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Note {
                         is_partial_move,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -1587,6 +1587,7 @@ pub fn is_stable_diagnostic_attribute(sym: Symbol, features: &Features) -> bool
     match sym {
         sym::on_unimplemented | sym::do_not_recommend => true,
         sym::on_const => features.diagnostic_on_const(),
+        sym::on_move => features.diagnostic_on_move(),
         _ => false,
     }
 }

compiler/rustc_feature/src/unstable.rs

@@ -472,6 +472,8 @@ declare_features! (
     (unstable, derive_from, "1.91.0", Some(144889)),
     /// Allows giving non-const impls custom diagnostic messages if attempted to be used as const
     (unstable, diagnostic_on_const, "1.93.0", Some(143874)),
+    /// Allows giving on-move borrowck custom diagnostic messages for a type
+    (unstable, diagnostic_on_move, "CURRENT_RUSTC_VERSION", Some(150935)),
     /// Allows `#[doc(cfg(...))]`.
     (unstable, doc_cfg, "1.21.0", Some(43781)),
     /// Allows `#[doc(masked)]`.

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1180,13 +1180,18 @@ pub enum AttributeKind {
         directive: Option<Box<Directive>>,
     },
 
+    /// Represents `#[diagnostic::on_move]`
+    OnMove {
+        span: Span,
+        directive: Option<Box<Directive>>,
+    },
+
     /// Represents `#[rustc_on_unimplemented]` and `#[diagnostic::on_unimplemented]`.
     OnUnimplemented {
         span: Span,
         /// None if the directive was malformed in some way.
         directive: Option<Box<Directive>>,
     },
-
     /// Represents `#[optimize(size|speed)]`
     Optimize(OptimizeAttr, Span),
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -77,6 +77,7 @@ impl AttributeKind {
             NoStd(..) => No,
             NonExhaustive(..) => Yes, // Needed for rustdoc
             OnConst { .. } => Yes,
+            OnMove { .. } => Yes,
             OnUnimplemented { .. } => Yes,
             Optimize(..) => No,
             PanicRuntime => No,

compiler/rustc_lint/src/early/diagnostics.rs

@@ -498,6 +498,18 @@ impl<'a> Diagnostic<'a, ()> for DecorateAttrLint<'_, '_, '_> {
             &AttributeLintKind::MissingOptionsForOnConst => {
                 lints::MissingOptionsForOnConstAttr.into_diag(dcx, level)
             }
+            &AttributeLintKind::MalformedOnMoveAttr { span } => {
+                lints::MalformedOnMoveAttrLint { span }.into_diag(dcx, level)
+            }
+            &AttributeLintKind::OnMoveMalformedFormatLiterals { name } => {
+                lints::OnMoveMalformedFormatLiterals { name }.into_diag(dcx, level)
+            }
+            &AttributeLintKind::OnMoveMalformedAttrExpectedLiteralOrDelimiter => {
+                lints::OnMoveMalformedAttrExpectedLiteralOrDelimiter.into_diag(dcx, level)
+            }
+            &AttributeLintKind::MissingOptionsForOnMove => {
+                lints::MissingOptionsForOnMoveAttr.into_diag(dcx, level)
+            }
         }
     }
 }