Merge pull request #21182 from ChayimFriedman2/param-env

internal: Remove `TraitEnvironment`

Author: ChayimFriedman2

src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs

@@ -8,10 +8,9 @@ use std::fmt;
 use hir_def::{TraitId, TypeAliasId};
 use rustc_type_ir::inherent::{IntoKind, Ty as _};
 use tracing::debug;
-use triomphe::Arc;
 
 use crate::{
-    TraitEnvironment,
+    ParamEnvAndCrate,
     db::HirDatabase,
     infer::InferenceContext,
     next_solver::{
@@ -35,13 +34,13 @@ const AUTODEREF_RECURSION_LIMIT: usize = 20;
 ///   detects a cycle in the deref chain.
 pub fn autoderef<'db>(
     db: &'db dyn HirDatabase,
-    env: Arc<TraitEnvironment<'db>>,
+    env: ParamEnvAndCrate<'db>,
     ty: Canonical<'db, Ty<'db>>,
 ) -> impl Iterator<Item = Ty<'db>> + use<'db> {
     let interner = DbInterner::new_with(db, env.krate);
     let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let (ty, _) = infcx.instantiate_canonical(&ty);
-    let autoderef = Autoderef::new(&infcx, &env, ty);
+    let autoderef = Autoderef::new(&infcx, env.param_env, ty);
     let mut v = Vec::new();
     for (ty, _steps) in autoderef {
         // `ty` may contain unresolved inference variables. Since there's no chance they would be
@@ -111,21 +110,21 @@ struct AutoderefTraits {
 // borrows it.
 pub(crate) trait AutoderefCtx<'db> {
     fn infcx(&self) -> &InferCtxt<'db>;
-    fn env(&self) -> &TraitEnvironment<'db>;
+    fn param_env(&self) -> ParamEnv<'db>;
 }
 
 pub(crate) struct DefaultAutoderefCtx<'a, 'db> {
     infcx: &'a InferCtxt<'db>,
-    env: &'a TraitEnvironment<'db>,
+    param_env: ParamEnv<'db>,
 }
 impl<'db> AutoderefCtx<'db> for DefaultAutoderefCtx<'_, 'db> {
     #[inline]
     fn infcx(&self) -> &InferCtxt<'db> {
         self.infcx
     }
     #[inline]
-    fn env(&self) -> &TraitEnvironment<'db> {
-        self.env
+    fn param_env(&self) -> ParamEnv<'db> {
+        self.param_env
     }
 }
 
@@ -136,8 +135,8 @@ impl<'db> AutoderefCtx<'db> for InferenceContextAutoderefCtx<'_, '_, 'db> {
         &self.0.table.infer_ctxt
     }
     #[inline]
-    fn env(&self) -> &TraitEnvironment<'db> {
-        &self.0.table.trait_env
+    fn param_env(&self) -> ParamEnv<'db> {
+        self.0.table.param_env
     }
 }
 
@@ -201,7 +200,7 @@ where
                 // autoderef expect this type to have been structurally normalized.
                 if let TyKind::Alias(..) = ty.kind() {
                     let (normalized_ty, obligations) =
-                        structurally_normalize_ty(self.infcx(), self.env().env, ty)?;
+                        structurally_normalize_ty(self.infcx(), self.param_env(), ty)?;
                     self.state.obligations.extend(obligations);
                     (AutoderefKind::Builtin, normalized_ty)
                 } else {
@@ -231,10 +230,10 @@ impl<'a, 'db> Autoderef<'a, 'db> {
     #[inline]
     pub(crate) fn new_with_tracking(
         infcx: &'a InferCtxt<'db>,
-        env: &'a TraitEnvironment<'db>,
+        param_env: ParamEnv<'db>,
         base_ty: Ty<'db>,
     ) -> Self {
-        Self::new_impl(DefaultAutoderefCtx { infcx, env }, base_ty)
+        Self::new_impl(DefaultAutoderefCtx { infcx, param_env }, base_ty)
     }
 }
 
@@ -257,10 +256,10 @@ impl<'a, 'db> Autoderef<'a, 'db, usize> {
     #[inline]
     pub(crate) fn new(
         infcx: &'a InferCtxt<'db>,
-        env: &'a TraitEnvironment<'db>,
+        param_env: ParamEnv<'db>,
         base_ty: Ty<'db>,
     ) -> Self {
-        Self::new_impl(DefaultAutoderefCtx { infcx, env }, base_ty)
+        Self::new_impl(DefaultAutoderefCtx { infcx, param_env }, base_ty)
     }
 }
 
@@ -292,8 +291,8 @@ where
     }
 
     #[inline]
-    fn env(&self) -> &TraitEnvironment<'db> {
-        self.ctx.env()
+    fn param_env(&self) -> ParamEnv<'db> {
+        self.ctx.param_env()
     }
 
     #[inline]
@@ -339,7 +338,7 @@ where
 
         let trait_ref = TraitRef::new(interner, trait_.into(), [ty]);
         let obligation =
-            Obligation::new(interner, ObligationCause::new(), self.env().env, trait_ref);
+            Obligation::new(interner, ObligationCause::new(), self.param_env(), trait_ref);
         // We detect whether the self type implements `Deref` before trying to
         // structurally normalize. We use `predicate_may_hold_opaque_types_jank`
         // to support not-yet-defined opaque types. It will succeed for `impl Deref`
@@ -351,7 +350,7 @@ where
 
         let (normalized_ty, obligations) = structurally_normalize_ty(
             self.infcx(),
-            self.env().env,
+            self.param_env(),
             Ty::new_projection(interner, trait_target.into(), [ty]),
         )?;
         debug!("overloaded_deref_ty({:?}) = ({:?}, {:?})", ty, normalized_ty, obligations);

src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs

@@ -5,7 +5,7 @@ mod tests;
 
 use base_db::Crate;
 use hir_def::{
-    ConstId, EnumVariantId, GeneralConstId, StaticId,
+    ConstId, EnumVariantId, GeneralConstId, HasModule, StaticId,
     attrs::AttrFlags,
     expr_store::Body,
     hir::{Expr, ExprId},
@@ -16,14 +16,14 @@ use rustc_type_ir::inherent::IntoKind;
 use triomphe::Arc;
 
 use crate::{
-    LifetimeElisionKind, MemoryMap, TraitEnvironment, TyLoweringContext,
+    LifetimeElisionKind, MemoryMap, ParamEnvAndCrate, TyLoweringContext,
     db::HirDatabase,
     display::DisplayTarget,
     infer::InferenceContext,
     mir::{MirEvalError, MirLowerError},
     next_solver::{
-        Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs, Ty,
-        ValueConst,
+        Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,
+        ParamEnv, Ty, ValueConst,
     },
 };
 
@@ -85,7 +85,7 @@ pub fn intern_const_ref<'a>(
     krate: Crate,
 ) -> Const<'a> {
     let interner = DbInterner::new_no_crate(db);
-    let layout = db.layout_of_ty(ty, TraitEnvironment::empty(krate));
+    let layout = db.layout_of_ty(ty, ParamEnvAndCrate { param_env: ParamEnv::empty(), krate });
     let kind = match value {
         LiteralConstRef::Int(i) => {
             // FIXME: We should handle failure of layout better.
@@ -207,7 +207,7 @@ pub(crate) fn const_eval_discriminant_variant<'db>(
     let mir_body = db.monomorphized_mir_body(
         def,
         GenericArgs::new_from_iter(interner, []),
-        db.trait_environment_for_body(def),
+        ParamEnvAndCrate { param_env: db.trait_environment_for_body(def), krate: def.krate(db) },
     )?;
     let c = interpret_mir(db, mir_body, false, None)?.0?;
     let c = if is_signed {
@@ -259,7 +259,7 @@ pub(crate) fn const_eval_cycle_result<'db>(
     _: &'db dyn HirDatabase,
     _: ConstId,
     _: GenericArgs<'db>,
-    _: Option<Arc<TraitEnvironment<'db>>>,
+    _: Option<ParamEnvAndCrate<'db>>,
 ) -> Result<Const<'db>, ConstEvalError<'db>> {
     Err(ConstEvalError::MirLowerError(MirLowerError::Loop))
 }
@@ -282,9 +282,13 @@ pub(crate) fn const_eval_query<'db>(
     db: &'db dyn HirDatabase,
     def: ConstId,
     subst: GenericArgs<'db>,
-    trait_env: Option<Arc<TraitEnvironment<'db>>>,
+    trait_env: Option<ParamEnvAndCrate<'db>>,
 ) -> Result<Const<'db>, ConstEvalError<'db>> {
-    let body = db.monomorphized_mir_body(def.into(), subst, db.trait_environment(def.into()))?;
+    let body = db.monomorphized_mir_body(
+        def.into(),
+        subst,
+        ParamEnvAndCrate { param_env: db.trait_environment(def.into()), krate: def.krate(db) },
+    )?;
     let c = interpret_mir(db, body, false, trait_env)?.0?;
     Ok(c)
 }
@@ -297,7 +301,10 @@ pub(crate) fn const_eval_static_query<'db>(
     let body = db.monomorphized_mir_body(
         def.into(),
         GenericArgs::new_from_iter(interner, []),
-        db.trait_environment_for_body(def.into()),
+        ParamEnvAndCrate {
+            param_env: db.trait_environment_for_body(def.into()),
+            krate: def.krate(db),
+        },
     )?;
     let c = interpret_mir(db, body, false, None)?.0?;
     Ok(c)

src/tools/rust-analyzer/crates/hir-ty/src/db.rs

@@ -12,13 +12,16 @@ use salsa::plumbing::AsId;
 use triomphe::Arc;
 
 use crate::{
-    ImplTraitId, TraitEnvironment, TyDefId, ValueTyDefId,
+    ImplTraitId, TyDefId, ValueTyDefId,
     consteval::ConstEvalError,
     dyn_compatibility::DynCompatibilityViolation,
     layout::{Layout, LayoutError},
     lower::{Diagnostics, GenericDefaults},
     mir::{BorrowckResult, MirBody, MirLowerError},
-    next_solver::{Const, EarlyBinder, GenericArgs, PolyFnSig, TraitRef, Ty, VariancesOf},
+    next_solver::{
+        Const, EarlyBinder, GenericArgs, ParamEnv, PolyFnSig, TraitRef, Ty, VariancesOf,
+    },
+    traits::ParamEnvAndCrate,
 };
 
 #[query_group::query_group]
@@ -46,15 +49,15 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         &'db self,
         def: DefWithBodyId,
         subst: GenericArgs<'db>,
-        env: Arc<TraitEnvironment<'db>>,
+        env: ParamEnvAndCrate<'db>,
     ) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>>;
 
     #[salsa::invoke(crate::mir::monomorphized_mir_body_for_closure_query)]
     fn monomorphized_mir_body_for_closure<'db>(
         &'db self,
         def: InternedClosureId,
         subst: GenericArgs<'db>,
-        env: Arc<TraitEnvironment<'db>>,
+        env: ParamEnvAndCrate<'db>,
     ) -> Result<Arc<MirBody<'db>>, MirLowerError<'db>>;
 
     #[salsa::invoke(crate::mir::borrowck_query)]
@@ -70,7 +73,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         &'db self,
         def: ConstId,
         subst: GenericArgs<'db>,
-        trait_env: Option<Arc<TraitEnvironment<'db>>>,
+        trait_env: Option<ParamEnvAndCrate<'db>>,
     ) -> Result<Const<'db>, ConstEvalError<'db>>;
 
     #[salsa::invoke(crate::consteval::const_eval_static_query)]
@@ -88,7 +91,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::transparent]
     fn lookup_impl_method<'db>(
         &'db self,
-        env: Arc<TraitEnvironment<'db>>,
+        env: ParamEnvAndCrate<'db>,
         func: FunctionId,
         fn_subst: GenericArgs<'db>,
     ) -> (FunctionId, GenericArgs<'db>);
@@ -101,15 +104,15 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         &'db self,
         def: AdtId,
         args: GenericArgs<'db>,
-        trait_env: Arc<TraitEnvironment<'db>>,
+        trait_env: ParamEnvAndCrate<'db>,
     ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::layout_of_ty_query)]
     #[salsa::cycle(cycle_result = crate::layout::layout_of_ty_cycle_result)]
     fn layout_of_ty<'db>(
         &'db self,
         ty: Ty<'db>,
-        env: Arc<TraitEnvironment<'db>>,
+        env: ParamEnvAndCrate<'db>,
     ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::target_data_layout_query)]
@@ -186,11 +189,10 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     #[salsa::invoke(crate::lower::trait_environment_for_body_query)]
     #[salsa::transparent]
-    fn trait_environment_for_body<'db>(&'db self, def: DefWithBodyId)
-    -> Arc<TraitEnvironment<'db>>;
+    fn trait_environment_for_body<'db>(&'db self, def: DefWithBodyId) -> ParamEnv<'db>;
 
     #[salsa::invoke(crate::lower::trait_environment_query)]
-    fn trait_environment<'db>(&'db self, def: GenericDefId) -> Arc<TraitEnvironment<'db>>;
+    fn trait_environment<'db>(&'db self, def: GenericDefId) -> ParamEnv<'db>;
 
     #[salsa::invoke(crate::lower::generic_defaults_with_diagnostics_query)]
     #[salsa::cycle(cycle_result = crate::lower::generic_defaults_with_diagnostics_cycle_result)]

src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs

@@ -25,15 +25,15 @@ use triomphe::Arc;
 use typed_arena::Arena;
 
 use crate::{
-    Adjust, InferenceResult, TraitEnvironment,
+    Adjust, InferenceResult,
     db::HirDatabase,
     diagnostics::match_check::{
         self,
         pat_analysis::{self, DeconstructedPat, MatchCheckCtx, WitnessPat},
     },
     display::{DisplayTarget, HirDisplay},
     next_solver::{
-        DbInterner, Ty, TyKind, TypingMode,
+        DbInterner, ParamEnv, Ty, TyKind, TypingMode,
         infer::{DbInternerInferExt, InferCtxt},
     },
 };
@@ -79,7 +79,7 @@ impl BodyValidationDiagnostic {
         let infer = InferenceResult::for_body(db, owner);
         let body = db.body(owner);
         let env = db.trait_environment_for_body(owner);
-        let interner = DbInterner::new_with(db, env.krate);
+        let interner = DbInterner::new_with(db, owner.krate(db));
         let infcx =
             interner.infer_ctxt().build(TypingMode::typeck_for_body(interner, owner.into()));
         let mut validator = ExprValidator {
@@ -100,7 +100,7 @@ struct ExprValidator<'db> {
     owner: DefWithBodyId,
     body: Arc<Body>,
     infer: &'db InferenceResult<'db>,
-    env: Arc<TraitEnvironment<'db>>,
+    env: ParamEnv<'db>,
     diagnostics: Vec<BodyValidationDiagnostic>,
     validate_lints: bool,
     infcx: InferCtxt<'db>,
@@ -210,7 +210,7 @@ impl<'db> ExprValidator<'db> {
             return;
         }
 
-        let cx = MatchCheckCtx::new(self.owner.module(self.db()), &self.infcx, self.env.clone());
+        let cx = MatchCheckCtx::new(self.owner.module(self.db()), &self.infcx, self.env);
 
         let pattern_arena = Arena::new();
         let mut m_arms = Vec::with_capacity(arms.len());
@@ -332,7 +332,7 @@ impl<'db> ExprValidator<'db> {
             return;
         };
         let pattern_arena = Arena::new();
-        let cx = MatchCheckCtx::new(self.owner.module(self.db()), &self.infcx, self.env.clone());
+        let cx = MatchCheckCtx::new(self.owner.module(self.db()), &self.infcx, self.env);
         for stmt in &**statements {
             let &Statement::Let { pat, initializer, else_branch: None, .. } = stmt else {
                 continue;