Undo some changes

Author: camelid

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -347,37 +347,6 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
         trace!("const eval: {:?} ({})", key, instance);
     }
 
-    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(uv) => {
-                assert_eq!(tcx.def_kind(uv.def), DefKind::AnonConst);
-
-                let id = GlobalId {
-                    instance: ty::Instance { def: ty::InstanceKind::Item(uv.def), args: uv.args },
-                    promoted: None,
-                };
-                return eval_in_interpreter(tcx, id, key.typing_env);
-            }
-            ty::ConstKind::Value(cv) => return Ok(tcx.valtree_to_const_alloc(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:?}")
-            }
-        };
-    }
-
     eval_in_interpreter(tcx, key.value, key.typing_env)
 }
 

compiler/rustc_ty_utils/src/instance.rs

@@ -1,5 +1,4 @@
 use rustc_errors::ErrorGuaranteed;
-use rustc_hir::def::DefKind;
 use rustc_hir::LangItem;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
@@ -11,12 +10,11 @@ use rustc_middle::ty::{
 };
 use rustc_span::sym;
 use rustc_trait_selection::traits;
-use tracing::{debug, instrument};
+use tracing::debug;
 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>)>,
@@ -92,32 +90,13 @@ fn resolve_instance_raw<'tcx>(
             let ty = args.type_at(0);
             ty::InstanceKind::AsyncDropGlue(def_id, ty)
         } else {
-            debug!(" => free or inherent item");
+            debug!(" => free item");
             ty::InstanceKind::Item(def_id)
         };
 
         Ok(Some(Instance { def, args }))
     };
-
-    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);
-            }
-        }
-    }
-
+    debug!("resolve_instance: result={:?}", result);
     result
 }