Add impl for separate_provide_extern

Author: camelid

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -402,6 +402,7 @@ provide! { tcx, def_id, other, cdata,
         tcx.arena.alloc_from_iter(cdata.get_doc_link_traits_in_scope(def_id.index))
     }
     anon_const_kind => { table }
+    const_of_item => { table }
 }
 
 pub(in crate::rmeta) fn provide(providers: &mut Providers) {

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1602,6 +1602,19 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             if let DefKind::AnonConst = def_kind {
                 record!(self.tables.anon_const_kind[def_id] <- self.tcx.anon_const_kind(def_id));
             }
+            if let DefKind::Const = def_kind {
+                record!(self.tables.const_of_item[def_id] <- self.tcx.const_of_item(def_id));
+            }
+            if let DefKind::AssocConst = def_kind {
+                let assoc_item = tcx.associated_item(def_id);
+                let should_encode = match assoc_item.container {
+                    ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => true,
+                    ty::AssocContainer::Trait => assoc_item.defaultness(tcx).has_value(),
+                };
+                if should_encode {
+                    record!(self.tables.const_of_item[def_id] <- self.tcx.const_of_item(def_id));
+                }
+            }
             if tcx.impl_method_has_trait_impl_trait_tys(def_id)
                 && let Ok(table) = self.tcx.collect_return_position_impl_trait_in_trait_tys(def_id)
             {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -468,6 +468,7 @@ define_tables! {
     assumed_wf_types_for_rpitit: Table<DefIndex, LazyArray<(Ty<'static>, Span)>>,
     opaque_ty_origin: Table<DefIndex, LazyValue<hir::OpaqueTyOrigin<DefId>>>,
     anon_const_kind: Table<DefIndex, LazyValue<ty::AnonConstKind>>,
+    const_of_item: Table<DefIndex, LazyValue<ty::EarlyBinder<'static, ty::Const<'static>>>>,
     associated_types_for_impl_traits_in_trait_or_impl: Table<DefIndex, LazyValue<DefIdMap<Vec<DefId>>>>,
 }
 

compiler/rustc_parse/src/parser/item.rs

@@ -1013,7 +1013,8 @@ impl<'a> Parser<'a> {
                             define_opaque,
                         }) => {
                             self.dcx().emit_err(errors::AssociatedStaticItemNotAllowed { span });
-                            let body = expr.map(|e| Box::new(AnonConst { id: DUMMY_NODE_ID, value: e }));
+                            let body =
+                                expr.map(|e| Box::new(AnonConst { id: DUMMY_NODE_ID, value: e }));
                             AssocItemKind::Const(Box::new(ConstItem {
                                 defaultness: Defaultness::Final,
                                 ident,
@@ -1483,7 +1484,8 @@ impl<'a> Parser<'a> {
         let before_where_clause =
             if self.may_recover() { self.parse_where_clause()? } else { WhereClause::default() };
 
-        let body = if self.eat(exp!(Eq)) { Some(Box::new(self.parse_expr_anon_const()?)) } else { None };
+        let body =
+            if self.eat(exp!(Eq)) { Some(Box::new(self.parse_expr_anon_const()?)) } else { None };
 
         let after_where_clause = self.parse_where_clause()?;