Don't look at static items' HIR for wfcheck

oli-obk · oli-obk · commit 3396d1d77712 · 2025-06-25T17:33:57.000Z
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -4862,6 +4862,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
@@ -729,7 +729,7 @@ 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> {
     let generics = tcx.generics_of(def_id);
 
     for param in &generics.own_params {
@@ -757,6 +757,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         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 => {
@@ -774,13 +775,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 => {
@@ -838,7 +836,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         DefKind::ForeignMod => {
             let it = tcx.hir_expect_item(def_id);
             let hir::ItemKind::ForeignMod { abi, items } = it.kind else {
-                return;
+                return Ok(());
             };
 
             check_abi(tcx, it.hir_id(), it.span, abi);
@@ -896,6 +894,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
@@ -185,17 +185,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::ConstBlock(_) | hir::Node::Expr(_) | hir::Node::OpaqueTy(_) => Ok(()),
         _ => unreachable!("{node:?}"),
-    };
+    });
 
     for param in &tcx.generics_of(def_id).own_params {
         res = res.and(check_param_wf(tcx, param));
@@ -291,9 +291,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);
@@ -347,10 +344,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(()),
     }
 }
 
@@ -1247,61 +1241,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, ty_span),
+                tcx.require_lang_item(LangItem::Sized, 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, ty_span),
+                tcx.require_lang_item(LangItem::Sync, DUMMY_SP),
             );
         }
         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
`@@ -4862,6 +4862,10 @@ impl<'hir> Node<'hir> {`
`4862`	`4862`	`ImplItemKind::Type(ty) => Some(ty),`
`4863`	`4863`	`_ => None,`
`4864`	`4864`	`},`
	`4865`	`+ Node::ForeignItem(it) => match it.kind {`
	`4866`	`+ ForeignItemKind::Static(ty, ..) => Some(ty),`
	`4867`	`+ _ => None,`
	`4868`	`+ },`
`4865`	`4869`	`_ => None,`
`4866`	`4870`	`}`
`4867`	`4871`	`}`
Original file line number	Diff line number	Diff line change
`@@ -729,7 +729,7 @@ fn check_static_linkage(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`729`	`729`	`}`
`730`	`730`	`}`
`731`	`731`
`732`		`-pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
	`732`	`+pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), ErrorGuaranteed> {`
`733`	`733`	`let generics = tcx.generics_of(def_id);`
`734`	`734`
`735`	`735`	`for param in &generics.own_params {`
`@@ -757,6 +757,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`757`	`757`	`DefKind::Static { .. } => {`
`758`	`758`	`check_static_inhabited(tcx, def_id);`
`759`	`759`	`check_static_linkage(tcx, def_id);`
	`760`	`+ wfcheck::check_static_item(tcx, def_id)?;`
`760`	`761`	`}`
`761`	`762`	`DefKind::Const => {}`
`762`	`763`	`DefKind::Enum => {`
`@@ -774,13 +775,10 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`774`	`775`	`}`
`775`	`776`	`DefKind::Impl { of_trait } => {`
`776`	`777`	`if of_trait && let Some(impl_trait_header) = tcx.impl_trait_header(def_id) {`
`777`		`- if tcx`
`778`		`- .ensure_ok()`
`779`		`- .coherent_trait(impl_trait_header.trait_ref.instantiate_identity().def_id)`
`780`		`- .is_ok()`
`781`		`- {`
`782`		`- check_impl_items_against_trait(tcx, def_id, impl_trait_header);`
`783`		`- }`
	`778`	`+ tcx.ensure_ok()`
	`779`	`+ .coherent_trait(impl_trait_header.trait_ref.instantiate_identity().def_id)?;`
	`780`	`+`
	`781`	`+ check_impl_items_against_trait(tcx, def_id, impl_trait_header);`
`784`	`782`	`}`
`785`	`783`	`}`
`786`	`784`	`DefKind::Trait => {`
`@@ -838,7 +836,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`838`	`836`	`DefKind::ForeignMod => {`
`839`	`837`	`let it = tcx.hir_expect_item(def_id);`
`840`	`838`	`let hir::ItemKind::ForeignMod { abi, items } = it.kind else {`
`841`		`- return;`
	`839`	`+ return Ok(());`
`842`	`840`	`};`
`843`	`841`
`844`	`842`	`check_abi(tcx, it.hir_id(), it.span, abi);`
`@@ -896,6 +894,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`896`	`894`	`}`
`897`	`895`	`_ => {}`
`898`	`896`	`}`
	`897`	`+ Ok(())`
`899`	`898`	`}`
`900`	`899`
`901`	`900`	`pub(super) fn check_on_unimplemented(tcx: TyCtxt<'_>, def_id: LocalDefId) {`