Fix more ICEs

Author: camelid

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -294,6 +294,29 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
                 )
             },
         );
+    } else if let ty::InstanceKind::Item(def_id) = key.value.instance.def
+        && matches!(tcx.def_kind(def_id), DefKind::Const | DefKind::AssocConst)
+    {
+        let ct = tcx.const_of_item(def_id).instantiate(tcx, key.value.instance.args);
+        match ct.kind() {
+            ty::ConstKind::Unevaluated(_) => {
+                return Err(ErrorHandled::TooGeneric(DUMMY_SP));
+            }
+            ty::ConstKind::Value(cv) => return Ok(tcx.valtree_to_const_val(cv)),
+            ty::ConstKind::Error(guar) => {
+                return Err(ErrorHandled::Reported(
+                    ReportedErrorInfo::const_eval_error(guar),
+                    DUMMY_SP,
+                ));
+            }
+            ty::ConstKind::Expr(_) => return Err(ErrorHandled::TooGeneric(DUMMY_SP)),
+            ty::ConstKind::Param(_) | ty::ConstKind::Placeholder(_) => {
+                return Err(ErrorHandled::TooGeneric(DUMMY_SP));
+            }
+            ty::ConstKind::Infer(_) | ty::ConstKind::Bound(..) => {
+                bug!("unexpected constant {ct:?}")
+            }
+        }
     }
 
     tcx.eval_to_allocation_raw(key).map(|val| turn_into_const_value(tcx, val, key))

compiler/rustc_hir/src/hir.rs

@@ -4844,35 +4844,17 @@ impl<'hir> Node<'hir> {
         match self {
             Node::Item(Item {
                 owner_id,
-                kind:
-                    ItemKind::Const(
-                        ..,
-                        ConstArg { kind: ConstArgKind::Anon(AnonConst { body, .. }), .. },
-                    )
-                    | ItemKind::Static(.., body)
-                    | ItemKind::Fn { body, .. },
+                kind: ItemKind::Static(.., body) | ItemKind::Fn { body, .. },
                 ..
             })
             | Node::TraitItem(TraitItem {
                 owner_id,
-                kind:
-                    TraitItemKind::Const(
-                        _,
-                        Some(ConstArg { kind: ConstArgKind::Anon(AnonConst { body, .. }), .. }),
-                    )
-                    | TraitItemKind::Fn(_, TraitFn::Provided(body)),
+                kind: TraitItemKind::Fn(_, TraitFn::Provided(body)),
                 ..
             })
-            | Node::ImplItem(ImplItem {
-                owner_id,
-                kind:
-                    ImplItemKind::Const(
-                        _,
-                        ConstArg { kind: ConstArgKind::Anon(AnonConst { body, .. }), .. },
-                    )
-                    | ImplItemKind::Fn(_, body),
-                ..
-            }) => Some((owner_id.def_id, *body)),
+            | Node::ImplItem(ImplItem { owner_id, kind: ImplItemKind::Fn(_, body), .. }) => {
+                Some((owner_id.def_id, *body))
+            }
 
             Node::Item(Item {
                 owner_id, kind: ItemKind::GlobalAsm { asm: _, fake_body }, ..

compiler/rustc_hir_analysis/src/lib.rs

@@ -214,12 +214,6 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
                 tcx.ensure_ok().eval_static_initializer(item_def_id);
                 check::maybe_check_static_with_link_section(tcx, item_def_id);
             }
-            DefKind::Const if tcx.generics_of(item_def_id).is_empty() => {
-                let instance = ty::Instance::new_raw(item_def_id.into(), ty::GenericArgs::empty());
-                let cid = GlobalId { instance, promoted: None };
-                let typing_env = ty::TypingEnv::fully_monomorphized();
-                tcx.ensure_ok().eval_to_const_value_raw(typing_env.as_query_input(cid));
-            }
             _ => (),
         }
         // Skip `AnonConst`s because we feed their `type_of`.

compiler/rustc_middle/src/mir/interpret/queries.rs

@@ -75,30 +75,6 @@ impl<'tcx> TyCtxt<'tcx> {
         // FIXME: maybe have a separate version for resolving mir::UnevaluatedConst?
         match ty::Instance::try_resolve(self, typing_env, ct.def, ct.args) {
             Ok(Some(instance)) => {
-                if let ty::InstanceKind::Item(def_id) = instance.def
-                    && matches!(self.def_kind(def_id), DefKind::Const | DefKind::AssocConst)
-                {
-                    let ct = self.const_of_item(def_id).instantiate(self, instance.args);
-                    match ct.kind() {
-                        ty::ConstKind::Unevaluated(_) => {
-                            return Err(ErrorHandled::TooGeneric(DUMMY_SP));
-                        }
-                        ty::ConstKind::Value(cv) => return Ok(self.valtree_to_const_val(cv)),
-                        ty::ConstKind::Error(guar) => {
-                            return Err(ErrorHandled::Reported(
-                                ReportedErrorInfo::const_eval_error(guar),
-                                DUMMY_SP,
-                            ));
-                        }
-                        ty::ConstKind::Expr(_) => return Err(ErrorHandled::TooGeneric(DUMMY_SP)),
-                        ty::ConstKind::Param(_) | ty::ConstKind::Placeholder(_) => {
-                            return Err(ErrorHandled::TooGeneric(DUMMY_SP));
-                        }
-                        ty::ConstKind::Infer(_) | ty::ConstKind::Bound(..) => {
-                            bug!("unexpected constant {ct:?}")
-                        }
-                    }
-                }
                 let cid = GlobalId { instance, promoted: ct.promoted };
                 self.const_eval_global_id(typing_env, cid, span)
             }