Use Instance::new_raw less

Author: compiler-errors

compiler/rustc_hir_analysis/src/lib.rs

@@ -101,7 +101,7 @@ use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, Const, Ty, TyCtxt};
 use rustc_session::parse::feature_err;
 use rustc_span::symbol::sym;
-use rustc_span::{ErrorGuaranteed, Span};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 use rustc_trait_selection::traits;
 
 pub use crate::collect::suggest_impl_trait;
@@ -216,9 +216,15 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
                 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();
+                let instance = ty::Instance::expect_resolve(
+                    tcx,
+                    typing_env,
+                    item_def_id.into(),
+                    ty::GenericArgs::empty(),
+                    DUMMY_SP,
+                );
+                let cid = GlobalId { instance, promoted: None };
                 tcx.ensure_ok().eval_to_const_value_raw(typing_env.as_query_input(cid));
             }
             _ => (),

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

@@ -1,3 +1,5 @@
+use std::assert_matches::debug_assert_matches;
+
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_session::lint;
@@ -18,14 +20,18 @@ impl<'tcx> TyCtxt<'tcx> {
     /// generic parameter is used within the constant `ErrorHandled::TooGeneric` will be returned.
     #[instrument(skip(self), level = "debug")]
     pub fn const_eval_poly(self, def_id: DefId) -> EvalToConstValueResult<'tcx> {
+        debug_assert_matches!(
+            self.def_kind(def_id),
+            DefKind::Const | DefKind::AnonConst | DefKind::InlineConst
+        );
         // In some situations def_id will have generic parameters within scope, but they aren't allowed
         // to be used. So we can't use `Instance::mono`, instead we feed unresolved generic parameters
         // into `const_eval` which will return `ErrorHandled::TooGeneric` if any of them are
         // encountered.
         let args = GenericArgs::identity_for_item(self, def_id);
-        let instance = ty::Instance::new_raw(def_id, args);
-        let cid = GlobalId { instance, promoted: None };
         let typing_env = ty::TypingEnv::post_analysis(self, def_id);
+        let instance = ty::Instance::expect_resolve(self, typing_env, def_id, args, DUMMY_SP);
+        let cid = GlobalId { instance, promoted: None };
         self.const_eval_global_id(typing_env, cid, DUMMY_SP)
     }
 
@@ -34,14 +40,18 @@ impl<'tcx> TyCtxt<'tcx> {
     /// generic parameter is used within the constant `ErrorHandled::TooGeneric` will be returned.
     #[instrument(skip(self), level = "debug")]
     pub fn const_eval_poly_to_alloc(self, def_id: DefId) -> EvalToAllocationRawResult<'tcx> {
+        debug_assert_matches!(
+            self.def_kind(def_id),
+            DefKind::Const | DefKind::AnonConst | DefKind::InlineConst
+        );
         // In some situations def_id will have generic parameters within scope, but they aren't allowed
         // to be used. So we can't use `Instance::mono`, instead we feed unresolved generic parameters
         // into `const_eval` which will return `ErrorHandled::TooGeneric` if any of them are
         // encountered.
         let args = GenericArgs::identity_for_item(self, def_id);
-        let instance = ty::Instance::new_raw(def_id, args);
-        let cid = GlobalId { instance, promoted: None };
         let typing_env = ty::TypingEnv::post_analysis(self, def_id);
+        let instance = ty::Instance::expect_resolve(self, typing_env, def_id, args, DUMMY_SP);
+        let cid = GlobalId { instance, promoted: None };
         let inputs = self.erase_regions(typing_env.as_query_input(cid));
         self.eval_to_allocation_raw(inputs)
     }
@@ -203,14 +213,24 @@ impl<'tcx> TyCtxtEnsureOk<'tcx> {
     /// generic parameter is used within the constant `ErrorHandled::TooGeneric` will be returned.
     #[instrument(skip(self), level = "debug")]
     pub fn const_eval_poly(self, def_id: DefId) {
+        debug_assert_matches!(
+            self.tcx.def_kind(def_id),
+            DefKind::Const | DefKind::AnonConst | DefKind::InlineConst
+        );
         // In some situations def_id will have generic parameters within scope, but they aren't allowed
         // to be used. So we can't use `Instance::mono`, instead we feed unresolved generic parameters
         // into `const_eval` which will return `ErrorHandled::TooGeneric` if any of them are
         // encountered.
         let args = GenericArgs::identity_for_item(self.tcx, def_id);
-        let instance = ty::Instance::new_raw(def_id, self.tcx.erase_regions(args));
-        let cid = GlobalId { instance, promoted: None };
         let typing_env = ty::TypingEnv::post_analysis(self.tcx, def_id);
+        let instance = ty::Instance::expect_resolve(
+            self.tcx,
+            typing_env,
+            def_id,
+            self.tcx.erase_regions(args),
+            DUMMY_SP,
+        );
+        let cid = GlobalId { instance, promoted: None };
         // Const-eval shouldn't depend on lifetimes at all, so we can erase them, which should
         // improve caching of queries.
         let inputs = self.tcx.erase_regions(typing_env.as_query_input(cid));

compiler/rustc_middle/src/query/mod.rs

@@ -2471,7 +2471,7 @@ rustc_queries! {
     query resolve_instance_raw(
         key: ty::PseudoCanonicalInput<'tcx, (DefId, GenericArgsRef<'tcx>)>
     ) -> Result<Option<ty::Instance<'tcx>>, ErrorGuaranteed> {
-        desc { "resolving instance `{}`", ty::Instance::new_raw(key.value.0, key.value.1) }
+        desc { |tcx| "resolving instance `{}`", tcx.def_path_str_with_args(key.value.0, key.value.1) }
     }
 
     query reveal_opaque_types_in_bounds(key: ty::Clauses<'tcx>) -> ty::Clauses<'tcx> {

src/tools/clippy/clippy_lints/src/non_copy_const.rs

@@ -263,12 +263,12 @@ impl<'tcx> NonCopyConst<'tcx> {
     fn is_value_unfrozen_poly(cx: &LateContext<'tcx>, body_id: BodyId, ty: Ty<'tcx>) -> bool {
         let def_id = body_id.hir_id.owner.to_def_id();
         let args = ty::GenericArgs::identity_for_item(cx.tcx, def_id);
-        let instance = ty::Instance::new_raw(def_id, args);
+        let typing_env = ty::TypingEnv::post_analysis(cx.tcx, def_id);
+        let instance = ty::Instance::expect_resolve(self.tcx,typing_env,def_id, args, DUMMY_SP);
         let cid = GlobalId {
             instance,
             promoted: None,
         };
-        let typing_env = ty::TypingEnv::post_analysis(cx.tcx, def_id);
         let result = cx.tcx.const_eval_global_id_for_typeck(typing_env, cid, DUMMY_SP);
         Self::is_value_unfrozen_raw(cx, result, ty)
     }