Introduce #[diagnostic::on_move]

This might be helpful for smart pointers to explains why they aren't Copy
and what to do instead or just to let the user know that .clone() is very
cheap and can be called without a performance penalty.

Author: rperier

Cargo.lock

@@ -3568,6 +3568,7 @@ dependencies = [
  "itertools",
  "polonius-engine",
  "rustc_abi",
+ "rustc_ast",
  "rustc_data_structures",
  "rustc_errors",
  "rustc_fluent_macro",
@@ -3579,6 +3580,7 @@ dependencies = [
  "rustc_macros",
  "rustc_middle",
  "rustc_mir_dataflow",
+ "rustc_parse_format",
  "rustc_session",
  "rustc_span",
  "rustc_trait_selection",

compiler/rustc_borrowck/Cargo.toml

@@ -9,6 +9,7 @@ either = "1.5.0"
 itertools = "0.12"
 polonius-engine = "0.13.0"
 rustc_abi = { path = "../rustc_abi" }
+rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
@@ -20,6 +21,7 @@ rustc_lexer = { path = "../rustc_lexer" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_mir_dataflow = { path = "../rustc_mir_dataflow" }
+rustc_parse_format = { path = "../rustc_parse_format" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }

compiler/rustc_borrowck/messages.ftl

@@ -77,6 +77,9 @@ borrowck_higher_ranked_lifetime_error =
 borrowck_higher_ranked_subtype_error =
     higher-ranked subtype error
 
+borrowck_ignored_diagnostic_option = `{$option_name}` is ignored due to previous definition of `{$option_name}`
+    .other_label = `{$option_name}` is first declared here
+    .label = `{$option_name}` is already declared here
 borrowck_implicit_static =
     this has an implicit `'static` lifetime requirement
 
@@ -92,6 +95,13 @@ borrowck_lifetime_constraints_error =
 borrowck_limitations_implies_static =
     due to a current limitation of the type system, this implies a `'static` lifetime
 
+borrowck_malformed_on_move_attr = unknown or malformed `on_move` attribute
+    .help = only `message` and `label` are allowed as options
+    .label = invalid option found here
+
+borrowck_missing_options_for_on_move_attr = missing options for `on_move` attribute
+    .help = at least one of the `message` and `label` options are expected
+
 borrowck_move_closure_suggestion =
     consider adding 'move' keyword before the nested closure
 
@@ -216,6 +226,8 @@ borrowck_ty_no_impl_copy =
         *[false] move
     } occurs because {$place} has type `{$ty}`, which does not implement the `Copy` trait
 
+borrowck_unknown_format_parameter_for_on_move_attr = unknown parameter `{$argument_name}`
+    .help = expect {"`{Self}`"} as format argument
 borrowck_use_due_to_use_closure =
     use occurs due to use in closure
 

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -327,18 +327,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

@@ -7,14 +7,16 @@ use std::iter;
 use std::ops::ControlFlow;
 
 use either::Either;
-use hir::{ClosureKind, Path};
+use hir::{AttrArgs, Attribute, ClosureKind, Path};
+use rustc_ast::{LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit};
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, Diag, MultiSpan, struct_span_code_err};
 use rustc_hir as hir;
 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_macros::LintDiagnostic;
 use rustc_middle::bug;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::{
@@ -29,9 +31,13 @@ use rustc_middle::ty::{
     suggest_constraining_type_params,
 };
 use rustc_mir_dataflow::move_paths::{InitKind, MoveOutIndex, MovePathIndex};
+use rustc_parse_format::{ParseMode, Parser, Piece, Position};
+use rustc_session::lint::builtin::{
+    MALFORMED_DIAGNOSTIC_ATTRIBUTES, MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
+};
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::hygiene::DesugaringKind;
-use rustc_span::{BytePos, Ident, Span, Symbol, kw, sym};
+use rustc_span::{BytePos, Ident, InnerSpan, Span, Symbol, kw, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::error_reporting::traits::FindExprBySpan;
 use rustc_trait_selection::error_reporting::traits::call_kind::CallKind;
@@ -69,6 +75,148 @@ enum StorageDeadOrDrop<'tcx> {
     Destructor(Ty<'tcx>),
 }
 
+#[derive(Debug)]
+struct OnMoveDirective {
+    message: Option<(Span, String)>,
+    label: Option<(Span, String)>,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(borrowck_unknown_format_parameter_for_on_move_attr)]
+#[help]
+struct UnknownFormatParameterForOnMoveAttr {
+    argument_name: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(borrowck_malformed_on_move_attr)]
+#[help]
+struct MalformedOnMoveAttr {
+    #[label]
+    span: Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(borrowck_missing_options_for_on_move_attr)]
+#[help]
+struct MissingOptionsForOnMoveAttr;
+
+#[derive(LintDiagnostic)]
+#[diag(borrowck_ignored_diagnostic_option)]
+struct IgnoredDiagnosticOption {
+    option_name: &'static str,
+    #[label]
+    span: Span,
+    #[label(borrowck_other_label)]
+    prev_span: Span,
+}
+impl IgnoredDiagnosticOption {
+    fn maybe_emit_warning<'tcx>(
+        tcx: TyCtxt<'tcx>,
+        item_def_id: DefId,
+        new: Option<Span>,
+        old: Option<Span>,
+        option_name: &'static str,
+    ) {
+        if let (Some(new_item), Some(old_item)) = (new, old)
+            && let Some(item_def_id) = item_def_id.as_local()
+        {
+            tcx.emit_node_span_lint(
+                MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                tcx.local_def_id_to_hir_id(item_def_id),
+                new_item,
+                IgnoredDiagnosticOption { span: new_item, prev_span: old_item, option_name },
+            );
+        }
+    }
+}
+
+impl<'tcx> OnMoveDirective {
+    fn new() -> Self {
+        Self { message: None, label: None }
+    }
+    fn parse(tcx: TyCtxt<'tcx>, item_def_id: DefId, items: &[MetaItemInner]) -> Self {
+        let get_value_and_span = |item: &_, key| {
+            if let MetaItemInner::MetaItem(MetaItem {
+                path,
+                kind: MetaItemKind::NameValue(MetaItemLit { span, kind: LitKind::Str(s, _), .. }),
+                ..
+            }) = item
+                && *path == key
+            {
+                Some((*s, *span))
+            } else {
+                None
+            }
+        };
+        let parse_value = |value: Symbol, span: Span| {
+            let mut parser = Parser::new(value.as_str(), None, None, false, ParseMode::Diagnostic);
+            let mut value = String::new();
+            let pieces: Vec<_> = parser.by_ref().collect();
+
+            for piece in pieces {
+                match piece {
+                    Piece::Lit(lit) => value.push_str(lit),
+                    Piece::NextArgument(arg) => match arg.position {
+                        Position::ArgumentNamed(name) if name == kw::SelfUpper.as_str() => {
+                            let slf = match tcx.opt_item_name(item_def_id) {
+                                Some(name) => name.to_string(),
+                                None => "Self".to_string(),
+                            };
+                            value.push_str(&slf);
+                        }
+                        Position::ArgumentNamed(name) => {
+                            if let Some(item_def_id) = item_def_id.as_local() {
+                                let span = span.from_inner(InnerSpan {
+                                    start: arg.position_span.start,
+                                    end: arg.position_span.end,
+                                });
+                                tcx.emit_node_span_lint(
+                                    MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
+                                    tcx.local_def_id_to_hir_id(item_def_id),
+                                    span,
+                                    UnknownFormatParameterForOnMoveAttr {
+                                        argument_name: name.to_string(),
+                                    },
+                                );
+                            }
+                            value.push_str(format!("{{{name}}}").as_str());
+                        }
+                        _ => {}
+                    },
+                }
+            }
+            value
+        };
+        let mut message = None;
+        let mut label = None;
+        for item in items {
+            if let Some((message_, span)) = get_value_and_span(item, sym::message)
+                && message.is_none()
+            {
+                let value = parse_value(message_, span);
+                message = Some((item.span(), value));
+                continue;
+            } else if let Some((label_, span)) = get_value_and_span(item, sym::label)
+                && label.is_none()
+            {
+                let value = parse_value(label_, span);
+                label = Some((item.span(), value));
+                continue;
+            }
+            if let Some(def_id) = item_def_id.as_local() {
+                tcx.emit_node_span_lint(
+                    MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                    tcx.local_def_id_to_hir_id(def_id),
+                    vec![item.span()],
+                    MalformedOnMoveAttr { span: item.span() },
+                );
+            }
+        }
+        Self { message, label }
+    }
+}
+
 impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     pub(crate) fn report_use_of_moved_or_uninitialized(
         &mut self,
@@ -141,6 +289,75 @@ 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 mut on_move_directive = if let ty::Adt(item_def, _) =
+                self.body.local_decls[moved_place.local].ty.kind()
+            {
+                self.infcx
+                    .tcx
+                    .get_attrs_by_path(item_def.did(), &[sym::diagnostic, sym::on_move])
+                    .fold(None, |acc: Option<OnMoveDirective>, attr| {
+                        if let Some(items) = attr.meta_item_list() {
+                            let directive =
+                                OnMoveDirective::parse(self.infcx.tcx, item_def.did(), &items);
+                            if let Some(acc) = acc {
+                                IgnoredDiagnosticOption::maybe_emit_warning(
+                                    self.infcx.tcx,
+                                    item_def.did(),
+                                    directive.message.as_ref().map(|attr| attr.0),
+                                    acc.message.as_ref().map(|attr| attr.0),
+                                    "message",
+                                );
+
+                                IgnoredDiagnosticOption::maybe_emit_warning(
+                                    self.infcx.tcx,
+                                    item_def.did(),
+                                    directive.label.as_ref().map(|attr| attr.0),
+                                    acc.label.as_ref().map(|attr| attr.0),
+                                    "label",
+                                );
+
+                                Some(acc)
+                            } else {
+                                Some(directive)
+                            }
+                        } else {
+                            match attr {
+                                Attribute::Unparsed(p) if !matches!(p.args, AttrArgs::Empty) => {
+                                    if let Some(item_def_id) = item_def.did().as_local() {
+                                        self.infcx.tcx.emit_node_span_lint(
+                                            MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                                            self.infcx.tcx.local_def_id_to_hir_id(item_def_id),
+                                            attr.span(),
+                                            MalformedOnMoveAttr { span: attr.span() },
+                                        );
+                                    }
+                                }
+                                _ => {
+                                    if let Some(item_def_id) = item_def.did().as_local() {
+                                        self.infcx.tcx.emit_node_span_lint(
+                                            MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                                            self.infcx.tcx.local_def_id_to_hir_id(item_def_id),
+                                            attr.span(),
+                                            MissingOptionsForOnMoveAttr,
+                                        )
+                                    }
+                                }
+                            }
+                            Some(OnMoveDirective::new())
+                        }
+                    })
+            } else {
+                None
+            };
+
+            let message = if let Some(on_move_directive) = &mut on_move_directive
+                && let Some(message) = on_move_directive.message.take()
+            {
+                Some(message.1)
+            } else {
+                None
+            };
+
             let mut err = self.cannot_act_on_moved_value(
                 span,
                 desired_action.as_noun(),
@@ -149,6 +366,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     moved_place,
                     DescribePlaceOpt { including_downcast: true, including_tuple_field: true },
                 ),
+                message,
             );
 
             let reinit_spans = maybe_reinitialized_locations
@@ -278,12 +496,18 @@ 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_directive) = on_move_directive
+                        && let Some(label) = on_move_directive.label
+                    {
+                        err.span_label(span, label.1);
+                    } 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_passes/messages.ftl

@@ -100,6 +100,9 @@ passes_diagnostic_diagnostic_on_const_only_for_trait_impls =
     `#[diagnostic::on_const]` can only be applied to trait impls
     .label = not a trait impl
 
+passes_diagnostic_diagnostic_on_move_only_for_adt =
+    `#[diagnostic::on_move]` can only be applied to enums, structs or unions
+
 passes_diagnostic_diagnostic_on_unimplemented_only_for_traits =
     `#[diagnostic::on_unimplemented]` can only be applied to trait definitions