Add more tracking for the HIR source of well-formedness requirement

Author: estebank

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1270,7 +1270,7 @@ fn check_item_type(
                 traits::ObligationCause::new(
                     ty_span,
                     wfcx.body_def_id,
-                    ObligationCauseCode::WellFormed(None),
+                    ObligationCauseCode::WellFormed(Some(WellFormedLoc::Ty(item_id))),
                 ),
                 wfcx.param_env,
                 item_ty,

compiler/rustc_hir_analysis/src/hir_wf_check.rs

@@ -25,6 +25,7 @@ fn diagnostic_hir_wf_check<'tcx>(
     let def_id = match loc {
         WellFormedLoc::Ty(def_id) => def_id,
         WellFormedLoc::Param { function, param_idx: _ } => function,
+        WellFormedLoc::Expr(_) => return None,
     };
     let hir_id = tcx.local_def_id_to_hir_id(def_id);
 
@@ -79,7 +80,9 @@ fn diagnostic_hir_wf_check<'tcx>(
             let cause = traits::ObligationCause::new(
                 ty.span,
                 self.def_id,
-                traits::ObligationCauseCode::WellFormed(None),
+                traits::ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(
+                    ty.hir_id,
+                ))),
             );
 
             ocx.register_obligation(traits::Obligation::new(
@@ -191,6 +194,7 @@ fn diagnostic_hir_wf_check<'tcx>(
                 vec![&fn_decl.inputs[param_idx as usize]]
             }
         }
+        WellFormedLoc::Expr(_) => return None,
     };
     for ty in tys {
         visitor.visit_ty(ty);

compiler/rustc_hir_typeck/src/callee.rs

@@ -122,7 +122,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self.register_wf_obligation(
             output.into(),
             call_expr.span,
-            ObligationCauseCode::WellFormed(None),
+            ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(call_expr.hir_id))),
         );
 
         output

compiler/rustc_hir_typeck/src/expr.rs

@@ -1500,7 +1500,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let ty = Ty::new_array_with_const_len(tcx, t, count);
 
-        self.register_wf_obligation(ty.into(), expr.span, ObligationCauseCode::WellFormed(None));
+        self.register_wf_obligation(
+            ty.into(),
+            expr.span,
+            ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(expr.hir_id))),
+        );
 
         ty
     }

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -405,7 +405,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     pub fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> LoweredTy<'tcx> {
         let ty = self.lowerer().lower_ty(hir_ty);
-        self.register_wf_obligation(ty.into(), hir_ty.span, ObligationCauseCode::WellFormed(None));
+        self.register_wf_obligation(
+            ty.into(),
+            hir_ty.span,
+            ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(hir_ty.hir_id))),
+        );
         LoweredTy::from_raw(self, hir_ty.span, ty)
     }
 
@@ -516,7 +520,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         for arg in args.iter().filter(|arg| {
             matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
         }) {
-            self.register_wf_obligation(arg, expr.span, ObligationCauseCode::WellFormed(None));
+            self.register_wf_obligation(
+                arg,
+                expr.span,
+                ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(expr.hir_id))),
+            );
         }
     }
 
@@ -771,7 +779,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.register_wf_obligation(
                 ty.raw.into(),
                 qself.span,
-                ObligationCauseCode::WellFormed(None),
+                ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(hir_id))),
             );
             // Return directly on cache hit. This is useful to avoid doubly reporting
             // errors with default match binding modes. See #44614.
@@ -811,7 +819,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     self.register_wf_obligation(
                         ty.raw.into(),
                         qself.span,
-                        ObligationCauseCode::WellFormed(None),
+                        ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(hir_id))),
                     );
                 }
 
@@ -849,7 +857,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.register_wf_obligation(
                 ty.raw.into(),
                 qself.span,
-                ObligationCauseCode::WellFormed(None),
+                ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(hir_id))),
             );
         }
 

compiler/rustc_hir_typeck/src/method/confirm.rs

@@ -586,7 +586,13 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
         // the function type must also be well-formed (this is not
         // implied by the args being well-formed because of inherent
         // impls and late-bound regions - see issue #28609).
-        self.register_wf_obligation(fty.into(), self.span, ObligationCauseCode::WellFormed(None));
+        self.register_wf_obligation(
+            fty.into(),
+            self.span,
+            ObligationCauseCode::WellFormed(Some(traits::WellFormedLoc::Expr(
+                self.call_expr.hir_id,
+            ))),
+        );
     }
 
     ///////////////////////////////////////////////////////////////////////////

compiler/rustc_middle/src/traits/mod.rs

@@ -486,6 +486,8 @@ pub enum WellFormedLoc {
         /// being the last 'parameter'
         param_idx: usize,
     },
+    /// The HIR node for the expression that introduced this obligation.
+    Expr(HirId),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

@@ -871,8 +871,14 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     }
 
                     ty::PredicateKind::ObjectSafe(trait_def_id) => {
+                        let mut hir_id = None;
+                        if let ObligationCauseCode::WellFormed(Some(
+                            crate::traits::WellFormedLoc::Expr(id),
+                        )) = root_obligation.cause.code() {
+                            hir_id = Some(*id);
+                        }
                         let violations = self.tcx.object_safety_violations(trait_def_id);
-                        report_object_safety_error(self.tcx, span, None, trait_def_id, violations)
+                        report_object_safety_error(self.tcx, span, hir_id, trait_def_id, violations)
                     }
 
                     ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(ty)) => {

tests/ui/consts/const_refs_to_static-ice-121413.rs

@@ -8,9 +8,11 @@ const REF_INTERIOR_MUT: &usize = {
     static FOO: Sync = AtomicUsize::new(0);
     //~^ ERROR failed to resolve: use of undeclared type `AtomicUsize`
     //~| WARN trait objects without an explicit `dyn` are deprecated
+    //~| WARN trait objects without an explicit `dyn` are deprecated
     //~| ERROR the size for values of type `(dyn Sync + 'static)` cannot be known at compilation time
     //~| ERROR the size for values of type `(dyn Sync + 'static)` cannot be known at compilation time
     //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+    //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
     unsafe { &*(&FOO as *const _ as *const usize) }
 };
 pub fn main() {}

tests/ui/consts/const_refs_to_static-ice-121413.stderr

@@ -23,6 +23,20 @@ help: if this is an object-safe trait, use `dyn`
 LL |     static FOO: dyn Sync = AtomicUsize::new(0);
    |                 +++
 
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/const_refs_to_static-ice-121413.rs:8:17
+   |
+LL |     static FOO: Sync = AtomicUsize::new(0);
+   |                 ^^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+help: if this is an object-safe trait, use `dyn`
+   |
+LL |     static FOO: dyn Sync = AtomicUsize::new(0);
+   |                 +++
+
 error[E0277]: the size for values of type `(dyn Sync + 'static)` cannot be known at compilation time
   --> $DIR/const_refs_to_static-ice-121413.rs:8:17
    |
@@ -40,7 +54,7 @@ LL |     static FOO: Sync = AtomicUsize::new(0);
    = help: the trait `Sized` is not implemented for `(dyn Sync + 'static)`
    = note: constant expressions must have a statically known size
 
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors; 2 warnings emitted
 
 Some errors have detailed explanations: E0277, E0433.
 For more information about an error, try `rustc --explain E0277`.