redact coerced type away

Author: dingxiangfei2009

compiler/rustc_hir_analysis/messages.ftl

@@ -85,6 +85,11 @@ hir_analysis_cmse_output_stack_spill =
     .note1 = functions with the `"{$abi_name}"` ABI must pass their result via the available return registers
     .note2 = the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
+hir_analysis_coerce_pointee_multiple_targets = `derive(CoercePointee)` only admits exactly one data field, {$diag_trait ->
+    [DispatchFromDyn] to which `dyn` methods shall be dispatched
+    *[CoerceUnsized] on which unsize coercion shall be performed
+    }
+
 hir_analysis_coerce_pointee_no_field = `CoercePointee` can only be derived on `struct`s with at least one field
 
 hir_analysis_coerce_pointee_no_user_validity_assertion = asserting applicability of `derive(CoercePointee)` on a target data is forbidden

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -1,9 +1,12 @@
 //! Check properties that are required by built-in traits and set
 //! up data structures required by type-checking/codegen.
 
+mod diagnostics;
+
 use std::assert_matches::assert_matches;
 use std::collections::BTreeMap;
 
+use diagnostics::{extract_coerce_pointee_data, redact_fulfillment_err_for_coerce_pointee};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{ErrorGuaranteed, MultiSpan};
 use rustc_hir as hir;
@@ -12,19 +15,20 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::lang_items::LangItem;
 use rustc_infer::infer::{self, RegionResolutionError, TyCtxtInferExt};
 use rustc_infer::traits::Obligation;
+use rustc_middle::bug;
 use rustc_middle::ty::adjustment::CoerceUnsizedInfo;
 use rustc_middle::ty::print::PrintTraitRefExt as _;
 use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeVisitableExt, TypingMode, suggest_constraining_type_params,
 };
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, Symbol};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits::misc::{
     ConstParamTyImplementationError, CopyImplementationError, InfringingFieldsReason,
     type_allowed_to_implement_const_param_ty, type_allowed_to_implement_copy,
 };
 use rustc_trait_selection::traits::{self, ObligationCause, ObligationCtxt};
-use tracing::debug;
+use tracing::{debug, instrument};
 
 use crate::errors;
 
@@ -187,10 +191,10 @@ fn visit_implementation_of_const_param_ty(
     }
 }
 
+#[instrument(level = "debug", skip(checker), fields(impl_did = ?checker.impl_def_id))]
 fn visit_implementation_of_coerce_unsized(checker: &Checker<'_>) -> Result<(), ErrorGuaranteed> {
     let tcx = checker.tcx;
     let impl_did = checker.impl_def_id;
-    debug!("visit_implementation_of_coerce_unsized: impl_did={:?}", impl_did);
 
     // Just compute this for the side-effects, in particular reporting
     // errors; other parts of the code may demand it for the info of
@@ -199,11 +203,11 @@ fn visit_implementation_of_coerce_unsized(checker: &Checker<'_>) -> Result<(), E
     tcx.at(span).ensure_ok().coerce_unsized_info(impl_did)
 }
 
+#[instrument(level = "debug", skip(checker), fields(impl_did = ?checker.impl_def_id))]
 fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<(), ErrorGuaranteed> {
     let tcx = checker.tcx;
     let impl_did = checker.impl_def_id;
     let trait_ref = checker.impl_header.trait_ref.instantiate_identity();
-    debug!("visit_implementation_of_dispatch_from_dyn: impl_did={:?}", impl_did);
 
     let span = tcx.def_span(impl_did);
 
@@ -307,29 +311,45 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
                 .collect::<Vec<_>>();
 
             if coerced_fields.is_empty() {
-                res = Err(tcx.dcx().emit_err(errors::DispatchFromDynSingle {
-                    span,
-                    trait_name: "DispatchFromDyn",
-                    note: true,
-                }));
+                if extract_coerce_pointee_data(tcx, def_a.did()).is_some() {
+                    res = Err(tcx.dcx().span_delayed_bug(
+                        span,
+                        "a specialised message for CoercePointee is expected",
+                    ));
+                } else {
+                    res = Err(tcx.dcx().emit_err(errors::DispatchFromDynSingle {
+                        span,
+                        trait_name: "DispatchFromDyn",
+                        note: true,
+                    }));
+                }
             } else if coerced_fields.len() > 1 {
-                res = Err(tcx.dcx().emit_err(errors::DispatchFromDynMulti {
-                    span,
-                    coercions_note: true,
-                    number: coerced_fields.len(),
-                    coercions: coerced_fields
-                        .iter()
-                        .map(|field| {
-                            format!(
-                                "`{}` (`{}` to `{}`)",
-                                field.name,
-                                field.ty(tcx, args_a),
-                                field.ty(tcx, args_b),
-                            )
-                        })
-                        .collect::<Vec<_>>()
-                        .join(", "),
-                }));
+                if extract_coerce_pointee_data(tcx, def_a.did()).is_some() {
+                    let spans =
+                        coerced_fields.iter().map(|field| tcx.def_span(field.did)).collect();
+                    res = Err(tcx.dcx().emit_err(errors::CoercePointeeMultipleTargets {
+                        spans,
+                        diag_trait: "DispatchFromDyn",
+                    }));
+                } else {
+                    res = Err(tcx.dcx().emit_err(errors::DispatchFromDynMulti {
+                        span,
+                        coercions_note: true,
+                        number: coerced_fields.len(),
+                        coercions: coerced_fields
+                            .iter()
+                            .map(|field| {
+                                format!(
+                                    "`{}` (`{}` to `{}`)",
+                                    field.name,
+                                    field.ty(tcx, args_a),
+                                    field.ty(tcx, args_b),
+                                )
+                            })
+                            .collect::<Vec<_>>()
+                            .join(", "),
+                    }));
+                }
             } else {
                 let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
                 for field in coerced_fields {
@@ -343,8 +363,29 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
                         ]),
                     ));
                 }
-                let errors = ocx.select_all_or_error();
+                let mut errors = ocx.select_all_or_error();
                 if !errors.is_empty() {
+                    if let Some((pointee_idx, _)) = extract_coerce_pointee_data(tcx, def_a.did()) {
+                        let target_pointee = args_b.type_at(pointee_idx);
+                        let source_pointee = args_a.type_at(pointee_idx);
+                        let new_pointee = Ty::new_param(
+                            tcx,
+                            u32::MAX,
+                            Symbol::intern(&format!("{source_pointee} {{coerced}}")),
+                        );
+
+                        errors = errors
+                            .into_iter()
+                            .map(|err| {
+                                redact_fulfillment_err_for_coerce_pointee(
+                                    tcx,
+                                    err,
+                                    target_pointee,
+                                    new_pointee,
+                                )
+                            })
+                            .collect();
+                    }
                     res = Err(infcx.err_ctxt().report_fulfillment_errors(errors));
                 }
 
@@ -359,27 +400,29 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
     }
 }
 
+#[instrument(level = "debug", skip(tcx))]
 pub(crate) fn coerce_unsized_info<'tcx>(
     tcx: TyCtxt<'tcx>,
     impl_did: LocalDefId,
 ) -> Result<CoerceUnsizedInfo, ErrorGuaranteed> {
-    debug!("compute_coerce_unsized_info(impl_did={:?})", impl_did);
     let span = tcx.def_span(impl_did);
 
     let coerce_unsized_trait = tcx.require_lang_item(LangItem::CoerceUnsized, Some(span));
 
     let unsize_trait = tcx.require_lang_item(LangItem::Unsize, Some(span));
 
     let source = tcx.type_of(impl_did).instantiate_identity();
+    let self_ty = source;
     let trait_ref = tcx.impl_trait_ref(impl_did).unwrap().instantiate_identity();
     assert_eq!(trait_ref.def_id, coerce_unsized_trait);
     let target = trait_ref.args.type_at(1);
-    debug!("visit_implementation_of_coerce_unsized: {:?} -> {:?} (bound)", source, target);
+    let coerced_ty = target;
+    debug!("{:?} -> {:?} (bound)", source, target);
 
     let param_env = tcx.param_env(impl_did);
     assert!(!source.has_escaping_bound_vars());
 
-    debug!("visit_implementation_of_coerce_unsized: {:?} -> {:?} (free)", source, target);
+    debug!("{:?} -> {:?} (free)", source, target);
 
     let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
     let cause = ObligationCause::misc(span, impl_did);
@@ -508,12 +551,28 @@ pub(crate) fn coerce_unsized_info<'tcx>(
                 .collect::<Vec<_>>();
 
             if diff_fields.is_empty() {
+                if extract_coerce_pointee_data(tcx, def_a.did()).is_some() {
+                    return Err(tcx.dcx().span_delayed_bug(
+                        span,
+                        "a specialised message for CoercePointee is expected",
+                    ));
+                }
                 return Err(tcx.dcx().emit_err(errors::CoerceUnsizedOneField {
                     span,
                     trait_name: "CoerceUnsized",
                     note: true,
                 }));
             } else if diff_fields.len() > 1 {
+                if extract_coerce_pointee_data(tcx, def_a.did()).is_some() {
+                    let spans = diff_fields
+                        .iter()
+                        .map(|&(idx, _, _)| tcx.def_span(fields[idx].did))
+                        .collect();
+                    return Err(tcx.dcx().emit_err(errors::CoercePointeeMultipleTargets {
+                        spans,
+                        diag_trait: "CoerceUnsized",
+                    }));
+                }
                 let item = tcx.hir().expect_item(impl_did);
                 let span = if let ItemKind::Impl(hir::Impl { of_trait: Some(t), .. }) = &item.kind {
                     t.path.span
@@ -546,17 +605,42 @@ pub(crate) fn coerce_unsized_info<'tcx>(
     };
 
     // Register an obligation for `A: Trait<B>`.
+    let coerce_pointee_data = if let ty::Adt(def, _) = self_ty.kind() {
+        extract_coerce_pointee_data(tcx, def.did())
+    } else {
+        None
+    };
     let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
-    let cause = traits::ObligationCause::misc(span, impl_did);
+    let cause = traits::ObligationCause::misc(
+        span,
+        coerce_pointee_data.map_or(impl_did, |(_, impl_did)| impl_did.expect_local()),
+    );
     let obligation = Obligation::new(
         tcx,
         cause,
         param_env,
         ty::TraitRef::new(tcx, trait_def_id, [source, target]),
     );
     ocx.register_obligation(obligation);
-    let errors = ocx.select_all_or_error();
+    let mut errors = ocx.select_all_or_error();
     if !errors.is_empty() {
+        if let Some((pointee, _)) = coerce_pointee_data {
+            let ty::Adt(_def, args) = coerced_ty.kind() else { bug!() };
+            let target_pointee = args.type_at(pointee);
+            let ty::Adt(_def, args) = self_ty.kind() else { bug!() };
+            let source_pointee = args.type_at(pointee);
+            let new_pointee = Ty::new_param(
+                tcx,
+                u32::MAX,
+                Symbol::intern(&format!("{source_pointee} {{coerced}}")),
+            );
+            errors = errors
+                .into_iter()
+                .map(|err| {
+                    redact_fulfillment_err_for_coerce_pointee(tcx, err, target_pointee, new_pointee)
+                })
+                .collect();
+        }
         infcx.err_ctxt().report_fulfillment_errors(errors);
     }