const body span is const item span

Author: BoxyUwU

compiler/rustc_hir_typeck/src/lib.rs

@@ -118,16 +118,7 @@ fn typeck_with_inspect<'tcx>(
 
     let id = tcx.local_def_id_to_hir_id(def_id);
     let node = tcx.hir_node(id);
-
-    // TODO: yikes
-    let (def_id_diagnostics, span) = if tcx.def_kind(def_id) == DefKind::AnonConst
-        && tcx.anon_const_kind(def_id) == ty::AnonConstKind::ItemBody
-    {
-        let const_item = tcx.parent(def_id.to_def_id());
-        (const_item.expect_local(), tcx.def_span(const_item))
-    } else {
-        (def_id, tcx.def_span(def_id))
-    };
+    let span = tcx.def_span(def_id);
 
     // Figure out what primary body this item has.
     let body_id = node.body_id().unwrap_or_else(|| {
@@ -207,7 +198,7 @@ fn typeck_with_inspect<'tcx>(
 
         let expected_type = fcx.normalize(body.value.span, expected_type);
 
-        let wf_code = ObligationCauseCode::WellFormed(Some(WellFormedLoc::Ty(def_id_diagnostics)));
+        let wf_code = ObligationCauseCode::WellFormed(Some(WellFormedLoc::Ty(def_id)));
         fcx.register_wf_obligation(expected_type.into(), body.value.span, wf_code);
 
         fcx.check_expr_coercible_to_type(body.value, expected_type, None);

compiler/rustc_middle/src/hir/map.rs

@@ -984,6 +984,9 @@ impl<'tcx> TyCtxt<'tcx> {
                 // Ensure that the returned span has the item's SyntaxContext.
                 fn_decl_span.find_ancestor_inside(*span).unwrap_or(*span)
             }
+            Node::AnonConst(anon) if let crate::ty::AnonConstKind::ItemBody = self.anon_const_kind(anon.def_id) => {
+                return self.hir_span(self.parent_hir_id(self.parent_hir_id(hir_id)));
+            }
             _ => self.hir_span_with_body(hir_id),
         };
         debug_assert_eq!(span.ctxt(), self.hir_span_with_body(hir_id).ctxt());
@@ -1001,6 +1004,9 @@ impl<'tcx> TyCtxt<'tcx> {
             Node::ImplItem(impl_item) => impl_item.span,
             Node::Variant(variant) => variant.span,
             Node::Field(field) => field.span,
+            Node::AnonConst(anon) if let crate::ty::AnonConstKind::ItemBody = self.anon_const_kind(anon.def_id) => {
+                return self.hir_span_with_body(self.parent_hir_id(self.parent_hir_id(hir_id)));
+            }
             Node::AnonConst(constant) => constant.span,
             Node::ConstBlock(constant) => self.hir_body(constant.body).value.span,
             Node::ConstArg(const_arg) => const_arg.span(),

compiler/rustc_resolve/src/def_collector.rs

@@ -13,15 +13,15 @@ use rustc_span::hygiene::LocalExpnId;
 use rustc_span::{Span, Symbol, sym};
 use tracing::debug;
 
-use crate::{ImplTraitContext, InvocationParent, Resolver};
+use crate::{FxHashMap, ImplTraitContext, InvocationParent, Resolver};
 
 pub(crate) fn collect_definitions(
     resolver: &mut Resolver<'_, '_>,
     fragment: &AstFragment,
     expansion: LocalExpnId,
 ) {
     let invocation_parent = resolver.invocation_parents[&expansion];
-    let mut visitor = DefCollector { resolver, expansion, invocation_parent };
+    let mut visitor = DefCollector { resolver, expansion, invocation_parent, overriden_anon_const_spans: FxHashMap::default(), };
     fragment.visit_with(&mut visitor);
 }
 
@@ -30,6 +30,7 @@ struct DefCollector<'a, 'ra, 'tcx> {
     resolver: &'a mut Resolver<'ra, 'tcx>,
     invocation_parent: InvocationParent,
     expansion: LocalExpnId,
+    overriden_anon_const_spans: FxHashMap<NodeId, Span>,
 }
 
 impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
@@ -121,7 +122,13 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                 mutability: s.mutability,
                 nested: false,
             },
-            ItemKind::Const(..) => DefKind::Const,
+            ItemKind::Const(box ConstItem { body, .. }) => {
+                if let Some(anon) = body {
+                    self.overriden_anon_const_spans.insert(anon.id, i.span);
+                }
+                
+                DefKind::Const
+            }
             ItemKind::Fn(..) | ItemKind::Delegation(..) => DefKind::Fn,
             ItemKind::MacroDef(ident, def) => {
                 let edition = i.span.edition();
@@ -338,7 +345,13 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
         let (ident, def_kind) = match &i.kind {
             AssocItemKind::Fn(box Fn { ident, .. })
             | AssocItemKind::Delegation(box Delegation { ident, .. }) => (*ident, DefKind::AssocFn),
-            AssocItemKind::Const(box ConstItem { ident, .. }) => (*ident, DefKind::AssocConst),
+            AssocItemKind::Const(box ConstItem { ident, body, .. }) => {
+                if let Some(anon) = body {
+                    self.overriden_anon_const_spans.insert(anon.id, i.span);
+                }
+
+                (*ident, DefKind::AssocConst)
+            },
             AssocItemKind::Type(box TyAlias { ident, .. }) => (*ident, DefKind::AssocTy),
             AssocItemKind::MacCall(..) | AssocItemKind::DelegationMac(..) => {
                 return self.visit_macro_invoc(i.id);
@@ -357,7 +370,10 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
     }
 
     fn visit_anon_const(&mut self, constant: &'a AnonConst) {
-        let parent = self.create_def(constant.id, None, DefKind::AnonConst, constant.value.span);
+        // TODO: i dont think this actually does anything?? what does this span even correspond to
+        let span = self.overriden_anon_const_spans.get(&constant.id).copied().unwrap_or(constant.value.span);
+
+        let parent = self.create_def(constant.id, None, DefKind::AnonConst, span);
         self.with_parent(parent, |this| visit::walk_anon_const(this, constant));
     }