Recurse through const items in instance resolution

Author: camelid

compiler/rustc_middle/src/mir/consts.rs

@@ -362,22 +362,7 @@ impl<'tcx> Const<'tcx> {
             }
             Const::Unevaluated(uneval, _) => {
                 // FIXME: We might want to have a `try_eval`-like function on `Unevaluated`
-                let uneval_ty_ct = ty::Const::new_unevaluated(
-                    tcx,
-                    ty::UnevaluatedConst::new(uneval.def, uneval.args),
-                );
-                let mir_ct = tcx.normalize_erasing_regions(typing_env, uneval_ty_ct);
-                // FIXME: duplicated with above match arm
-                match mir_ct.kind() {
-                    ConstKind::Value(cv) => Ok(tcx.valtree_to_const_val(cv)),
-                    ConstKind::Expr(_) => {
-                        bug!("Normalization of `ty::ConstKind::Expr` is unimplemented")
-                    }
-                    _ => Err(ReportedErrorInfo::non_const_eval_error(
-                        tcx.dcx().delayed_bug("Unevaluated `ty::Const` in MIR body"),
-                    )
-                    .into()),
-                }
+                tcx.const_eval_resolve(typing_env, uneval, span)
             }
             Const::Val(val, _) => Ok(val),
         }

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

@@ -75,6 +75,30 @@ 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)
             }

compiler/rustc_resolve/src/def_collector.rs

@@ -176,7 +176,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     }
                     // HACK(mgca): see lower_const_item in ast_lowering
                     ItemKind::Const(box ConstItem { body_id: Some(body_id), .. }) => {
-                        this.create_def(body_id, None, DefKind::InlineConst, i.span);
+                        this.create_def(body_id, None, DefKind::AnonConst, i.span);
                     }
                     _ => {}
                 }
@@ -341,7 +341,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
         self.with_parent(def, |this| {
             // HACK(mgca): see lower_const_item in ast_lowering
             if let AssocItemKind::Const(box ConstItem { body_id: Some(body_id), .. }) = i.kind {
-                this.create_def(body_id, None, DefKind::InlineConst, i.span);
+                this.create_def(body_id, None, DefKind::AnonConst, i.span);
             }
             visit::walk_assoc_item(this, i, ctxt)
         });

compiler/rustc_ty_utils/src/instance.rs

@@ -1,5 +1,6 @@
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::LangItem;
+use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::bug;
@@ -10,11 +11,12 @@ use rustc_middle::ty::{
 };
 use rustc_span::sym;
 use rustc_trait_selection::traits;
-use tracing::debug;
+use tracing::{debug, instrument};
 use traits::translate_args;
 
 use crate::errors::UnexpectedFnPtrAssociatedItem;
 
+#[instrument(level = "debug", skip(tcx), ret)]
 fn resolve_instance_raw<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::PseudoCanonicalInput<'tcx, (DefId, GenericArgsRef<'tcx>)>,
@@ -90,13 +92,30 @@ fn resolve_instance_raw<'tcx>(
             let ty = args.type_at(0);
             ty::InstanceKind::AsyncDropGlue(def_id, ty)
         } else {
-            debug!(" => free item");
+            debug!(" => free or inherent item");
             ty::InstanceKind::Item(def_id)
         };
 
         Ok(Some(Instance { def, args }))
     };
-    debug!("resolve_instance: result={:?}", result);
+    if let Ok(Some(Instance { def: ty::InstanceKind::Item(def_id), args })) = result
+        && matches!(tcx.def_kind(def_id), DefKind::Const | DefKind::AssocConst)
+    {
+        debug!(" => resolved to const item");
+        let ct = tcx.const_of_item(def_id).instantiate(tcx, args);
+        debug!("ct={ct:?}");
+        if let ty::ConstKind::Unevaluated(uv) = ct.kind() {
+            if tcx.def_kind(uv.def) == DefKind::AnonConst {
+                return Ok(Some(ty::Instance {
+                    def: ty::InstanceKind::Item(uv.def),
+                    args: uv.args,
+                }));
+            } else {
+                let input = PseudoCanonicalInput { typing_env, value: (uv.def, uv.args) };
+                return tcx.resolve_instance_raw(input);
+            }
+        }
+    }
     result
 }