Don't look at static items' HIR for wfcheck

oli-obk · oli-obk · commit 944734d431b0 · 2025-06-04T10:43:37.000Z
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -4828,6 +4828,10 @@ impl<'hir> Node<'hir> {
                 ImplItemKind::Type(ty) => Some(ty),
                 _ => None,
             },
+            Node::ForeignItem(it) => match it.kind {
+                ForeignItemKind::Static(ty, ..) => Some(ty),
+                _ => None,
+            },
             _ => None,
         }
     }
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -701,11 +701,12 @@ fn check_static_linkage(tcx: TyCtxt<'_>, def_id: LocalDefId) {
     }
 }
 
-pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
+pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), ErrorGuaranteed> {
     match tcx.def_kind(def_id) {
         DefKind::Static { .. } => {
             check_static_inhabited(tcx, def_id);
             check_static_linkage(tcx, def_id);
+            wfcheck::check_static_item(tcx, def_id)?;
         }
         DefKind::Const => {}
         DefKind::Enum => {
@@ -723,13 +724,10 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         }
         DefKind::Impl { of_trait } => {
             if of_trait && let Some(impl_trait_header) = tcx.impl_trait_header(def_id) {
-                if tcx
-                    .ensure_ok()
-                    .coherent_trait(impl_trait_header.trait_ref.instantiate_identity().def_id)
-                    .is_ok()
-                {
-                    check_impl_items_against_trait(tcx, def_id, impl_trait_header);
-                }
+                tcx.ensure_ok()
+                    .coherent_trait(impl_trait_header.trait_ref.instantiate_identity().def_id)?;
+
+                check_impl_items_against_trait(tcx, def_id, impl_trait_header);
             }
         }
         DefKind::Trait => {
@@ -775,11 +773,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
             check_type_alias_type_params_are_used(tcx, def_id);
         }
         DefKind::ForeignMod => {
-            let it = tcx.hir_expect_item(def_id);
-            let hir::ItemKind::ForeignMod { abi, items } = it.kind else {
-                return;
-            };
-            check_abi(tcx, it.span, abi);
+            let (abi, items) = tcx.hir_expect_item(def_id).expect_foreign_mod();
+            check_abi(tcx, tcx.def_span(def_id), abi);
 
             for item in items {
                 let def_id = item.id.owner_id.def_id;
@@ -825,6 +820,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         }
         _ => {}
     }
+    Ok(())
 }
 
 pub(super) fn check_on_unimplemented(tcx: TyCtxt<'_>, def_id: LocalDefId) {
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -186,17 +186,17 @@ where
 }
 
 fn check_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), ErrorGuaranteed> {
-    crate::check::check::check_item_type(tcx, def_id);
+    let mut res = crate::check::check::check_item_type(tcx, def_id);
     let node = tcx.hir_node_by_def_id(def_id);
-    let mut res = match node {
+    res = res.and(match node {
         hir::Node::Crate(_) => bug!("check_well_formed cannot be applied to the crate root"),
         hir::Node::Item(item) => check_item(tcx, item),
         hir::Node::TraitItem(item) => check_trait_item(tcx, item),
         hir::Node::ImplItem(item) => check_impl_item(tcx, item),
         hir::Node::ForeignItem(item) => check_foreign_item(tcx, item),
         hir::Node::OpaqueTy(_) => Ok(()),
         _ => unreachable!("{node:?}"),
-    };
+    });
 
     for param in &tcx.generics_of(def_id).own_params {
         res = res.and(check_param_wf(tcx, param));
@@ -292,9 +292,6 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
             res
         }
         hir::ItemKind::Fn { ident, sig, .. } => check_item_fn(tcx, def_id, ident, sig.decl),
-        hir::ItemKind::Static(_, _, ty, _) => {
-            check_static_item(tcx, def_id, ty.span, UnsizedHandling::Forbid)
-        }
         hir::ItemKind::Const(_, _, ty, _) => check_const_item(tcx, def_id, ty.span, item.span),
         hir::ItemKind::Struct(_, generics, _) => {
             let res = check_type_defn(tcx, item, false);
@@ -350,10 +347,7 @@ fn check_foreign_item<'tcx>(
 
     match item.kind {
         hir::ForeignItemKind::Fn(sig, ..) => check_item_fn(tcx, def_id, item.ident, sig.decl),
-        hir::ForeignItemKind::Static(ty, ..) => {
-            check_static_item(tcx, def_id, ty.span, UnsizedHandling::AllowIfForeignTail)
-        }
-        hir::ForeignItemKind::Type => Ok(()),
+        hir::ForeignItemKind::Static(..) | hir::ForeignItemKind::Type => Ok(()),
     }
 }
 
@@ -1315,61 +1309,52 @@ fn check_item_fn(
     })
 }
 
-enum UnsizedHandling {
-    Forbid,
-    AllowIfForeignTail,
-}
-
-#[instrument(level = "debug", skip(tcx, ty_span, unsized_handling))]
-fn check_static_item(
+#[instrument(level = "debug", skip(tcx))]
+pub(super) fn check_static_item(
     tcx: TyCtxt<'_>,
     item_id: LocalDefId,
-    ty_span: Span,
-    unsized_handling: UnsizedHandling,
 ) -> Result<(), ErrorGuaranteed> {
     enter_wf_checking_ctxt(tcx, item_id, |wfcx| {
         let ty = tcx.type_of(item_id).instantiate_identity();
-        let item_ty = wfcx.deeply_normalize(ty_span, Some(WellFormedLoc::Ty(item_id)), ty);
-
-        let forbid_unsized = match unsized_handling {
-            UnsizedHandling::Forbid => true,
-            UnsizedHandling::AllowIfForeignTail => {
-                let tail =
-                    tcx.struct_tail_for_codegen(item_ty, wfcx.infcx.typing_env(wfcx.param_env));
-                !matches!(tail.kind(), ty::Foreign(_))
-            }
+        let item_ty = wfcx.deeply_normalize(DUMMY_SP, Some(WellFormedLoc::Ty(item_id)), ty);
+
+        let is_foreign_item = tcx.is_foreign_item(item_id);
+
+        let forbid_unsized = !is_foreign_item || {
+            let tail = tcx.struct_tail_for_codegen(item_ty, wfcx.infcx.typing_env(wfcx.param_env));
+            !matches!(tail.kind(), ty::Foreign(_))
         };
 
-        wfcx.register_wf_obligation(ty_span, Some(WellFormedLoc::Ty(item_id)), item_ty.into());
+        wfcx.register_wf_obligation(DUMMY_SP, Some(WellFormedLoc::Ty(item_id)), item_ty.into());
         if forbid_unsized {
             wfcx.register_bound(
                 traits::ObligationCause::new(
-                    ty_span,
+                    DUMMY_SP,
                     wfcx.body_def_id,
                     ObligationCauseCode::SizedConstOrStatic,
                 ),
                 wfcx.param_env,
                 item_ty,
-                tcx.require_lang_item(LangItem::Sized, Some(ty_span)),
+                tcx.require_lang_item(LangItem::Sized, Some(tcx.def_span(item_id))),
             );
         }
 
         // Ensure that the end result is `Sync` in a non-thread local `static`.
         let should_check_for_sync = tcx.static_mutability(item_id.to_def_id())
             == Some(hir::Mutability::Not)
-            && !tcx.is_foreign_item(item_id.to_def_id())
+            && !is_foreign_item
             && !tcx.is_thread_local_static(item_id.to_def_id());
 
         if should_check_for_sync {
             wfcx.register_bound(
                 traits::ObligationCause::new(
-                    ty_span,
+                    DUMMY_SP,
                     wfcx.body_def_id,
                     ObligationCauseCode::SharedStatic,
                 ),
                 wfcx.param_env,
                 item_ty,
-                tcx.require_lang_item(LangItem::Sync, Some(ty_span)),
+                tcx.require_lang_item(LangItem::Sync, Some(tcx.def_span(item_id))),
             );
         }
         Ok(())
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -31,7 +31,7 @@ use rustc_middle::ty::{
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::{BytePos, DUMMY_SP, STDLIB_STABLE_CRATES, Span, Symbol, sym};
-use tracing::{debug, instrument};
+use tracing::{debug, instrument, trace};
 
 use super::on_unimplemented::{AppendConstMessage, OnUnimplementedNote};
 use super::suggestions::get_explanation_based_on_obligation;
@@ -67,6 +67,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
         let mut err = match *error {
             SelectionError::Unimplemented => {
+                trace!(?root_obligation.cause);
                 // If this obligation was generated as a result of well-formedness checking, see if we
                 // can get a better error message by performing HIR-based well-formedness checking.
                 if let ObligationCauseCode::WellFormed(Some(wf_loc)) =
@@ -81,6 +82,12 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         span = obligation.cause.span;
                     }
                 }
+                if let ObligationCauseCode::SizedConstOrStatic | ObligationCauseCode::SharedStatic = root_obligation.cause.code() {
+                    let node = tcx.hir_node_by_def_id(root_obligation.cause.body_id);
+                    span = node.ty().unwrap_or_else(|| panic!("{node:?} had no type")).span;
+                    obligation.cause.span = span;
+                    trace!("patched up span")
+                }
 
                 if let ObligationCauseCode::CompareImplItem {
                     impl_item_def_id,

Original file line number	Diff line number	Diff line change
`@@ -4828,6 +4828,10 @@ impl<'hir> Node<'hir> {`
`4828`	`4828`	`ImplItemKind::Type(ty) => Some(ty),`
`4829`	`4829`	`_ => None,`
`4830`	`4830`	`},`
	`4831`	`+ Node::ForeignItem(it) => match it.kind {`
	`4832`	`+ ForeignItemKind::Static(ty, ..) => Some(ty),`
	`4833`	`+ _ => None,`
	`4834`	`+ },`
`4831`	`4835`	`_ => None,`
`4832`	`4836`	`}`
`4833`	`4837`	`}`
Original file line number	Diff line number	Diff line change
`@@ -701,11 +701,12 @@ fn check_static_linkage(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`701`	`701`	`}`
`702`	`702`	`}`
`703`	`703`
`704`		`-pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
	`704`	`+pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), ErrorGuaranteed> {`
`705`	`705`	`match tcx.def_kind(def_id) {`
`706`	`706`	`DefKind::Static { .. } => {`
`707`	`707`	`check_static_inhabited(tcx, def_id);`
`708`	`708`	`check_static_linkage(tcx, def_id);`
	`709`	`+ wfcheck::check_static_item(tcx, def_id)?;`
`709`	`710`	`}`
`710`	`711`	`DefKind::Const => {}`
`711`	`712`	`DefKind::Enum => {`
`@@ -723,13 +724,10 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`723`	`724`	`}`
`724`	`725`	`DefKind::Impl { of_trait } => {`
`725`	`726`	`if of_trait && let Some(impl_trait_header) = tcx.impl_trait_header(def_id) {`
`726`		`- if tcx`
`727`		`- .ensure_ok()`
`728`		`- .coherent_trait(impl_trait_header.trait_ref.instantiate_identity().def_id)`
`729`		`- .is_ok()`
`730`		`- {`
`731`		`- check_impl_items_against_trait(tcx, def_id, impl_trait_header);`
`732`		`- }`
	`727`	`+ tcx.ensure_ok()`
	`728`	`+ .coherent_trait(impl_trait_header.trait_ref.instantiate_identity().def_id)?;`
	`729`	`+`
	`730`	`+ check_impl_items_against_trait(tcx, def_id, impl_trait_header);`
`733`	`731`	`}`
`734`	`732`	`}`
`735`	`733`	`DefKind::Trait => {`
`@@ -775,11 +773,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`775`	`773`	`check_type_alias_type_params_are_used(tcx, def_id);`
`776`	`774`	`}`
`777`	`775`	`DefKind::ForeignMod => {`
`778`		`- let it = tcx.hir_expect_item(def_id);`
`779`		`- let hir::ItemKind::ForeignMod { abi, items } = it.kind else {`
`780`		`- return;`
`781`		`- };`
`782`		`- check_abi(tcx, it.span, abi);`
	`776`	`+ let (abi, items) = tcx.hir_expect_item(def_id).expect_foreign_mod();`
	`777`	`+ check_abi(tcx, tcx.def_span(def_id), abi);`
`783`	`778`
`784`	`779`	`for item in items {`
`785`	`780`	`let def_id = item.id.owner_id.def_id;`
`@@ -825,6 +820,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`825`	`820`	`}`
`826`	`821`	`_ => {}`
`827`	`822`	`}`
	`823`	`+ Ok(())`
`828`	`824`	`}`
`829`	`825`
`830`	`826`	`pub(super) fn check_on_unimplemented(tcx: TyCtxt<'_>, def_id: LocalDefId) {`