rust-analyzer

diff --git a/crates/hir-ty/src/consteval.rs b/crates/hir-ty/src/consteval.rs
index ddeb9f14b5..9792d945eb 100644
--- a/crates/hir-ty/src/consteval.rs
+++ b/crates/hir-ty/src/consteval.rs

@@ -137,7 +137,7 @@ pub fn intern_const_ref(

ty: Ty,

krate: CrateId,

) -> Const {

- let layout = db.layout_of_ty(ty.clone(), Arc::new(TraitEnvironment::empty(krate)));

+ let layout = db.layout_of_ty(ty.clone(), TraitEnvironment::empty(krate));

let bytes = match value {

LiteralConstRef::Int(i) => {

// FIXME: We should handle failure of layout better.

diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index a324129b35..d81926f7c9 100644
--- a/crates/hir-ty/src/display.rs
+++ b/crates/hir-ty/src/display.rs

@@ -448,9 +448,8 @@ fn render_const_scalar(

) -> Result<(), HirDisplayError> {

// FIXME: We need to get krate from the final callers of the hir display

// infrastructure and have it here as a field on `f`.

- let trait_env = Arc::new(TraitEnvironment::empty(

- *f.db.crate_graph().crates_in_topological_order().last().unwrap(),

- ));

+ let trait_env =

+ TraitEnvironment::empty(*f.db.crate_graph().crates_in_topological_order().last().unwrap());

match ty.kind(Interner) {

TyKind::Scalar(s) => match s {

Scalar::Bool => write!(f, "{}", if b[0] == 0 { false } else { true }),

diff --git a/crates/hir-ty/src/infer/expr.rs b/crates/hir-ty/src/infer/expr.rs
index 0c3c725a7c..24026202b7 100644
--- a/crates/hir-ty/src/infer/expr.rs
+++ b/crates/hir-ty/src/infer/expr.rs

@@ -18,7 +18,6 @@ use hir_def::{

use hir_expand::name::{name, Name};

use stdx::always;

use syntax::ast::RangeOp;

-use triomphe::Arc;

use crate::{

autoderef::{builtin_deref, deref_by_trait, Autoderef},

@@ -40,7 +39,8 @@ use crate::{

traits::FnTrait,

utils::{generics, Generics},

Adjust, Adjustment, AdtId, AutoBorrow, Binders, CallableDefId, FnPointer, FnSig, FnSubst,

- Interner, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyExt, TyKind,

+ Interner, Rawness, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt,

+ TyKind,

};

use super::{

@@ -1291,7 +1291,7 @@ impl InferenceContext<'_> {

let g = self.resolver.update_to_inner_scope(self.db.upcast(), self.owner, expr);

let prev_env = block_id.map(|block_id| {

let prev_env = self.table.trait_env.clone();

- Arc::make_mut(&mut self.table.trait_env).block = Some(block_id);

+ TraitEnvironment::with_block(&mut self.table.trait_env, block_id);

prev_env

});

diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs
index 5a3e423f15..cf174feed2 100644
--- a/crates/hir-ty/src/lib.rs
+++ b/crates/hir-ty/src/lib.rs

@@ -122,7 +122,7 @@ pub type TyKind = chalk_ir::TyKind<Interner>;

pub type TypeFlags = chalk_ir::TypeFlags;

pub type DynTy = chalk_ir::DynTy<Interner>;

pub type FnPointer = chalk_ir::FnPointer<Interner>;

-// pub type FnSubst = chalk_ir::FnSubst<Interner>;

+// pub type FnSubst = chalk_ir::FnSubst<Interner>; // a re-export so we don't lose the tuple constructor

pub use chalk_ir::FnSubst;

pub type ProjectionTy = chalk_ir::ProjectionTy<Interner>;

pub type AliasTy = chalk_ir::AliasTy<Interner>;

diff --git a/crates/hir-ty/src/lower.rs b/crates/hir-ty/src/lower.rs
index 2a6d69e7fc..c86fe9adff 100644
--- a/crates/hir-ty/src/lower.rs
+++ b/crates/hir-ty/src/lower.rs

@@ -1468,7 +1468,7 @@ pub(crate) fn trait_environment_for_body_query(

) -> Arc<TraitEnvironment> {

let Some(def) = def.as_generic_def_id() else {

let krate = def.module(db.upcast()).krate();

- return Arc::new(TraitEnvironment::empty(krate));

+ return TraitEnvironment::empty(krate);

};

db.trait_environment(def)

}

@@ -1528,12 +1528,7 @@ pub(crate) fn trait_environment_query(

let env = chalk_ir::Environment::new(Interner).add_clauses(Interner, clauses);

- Arc::new(TraitEnvironment {

- krate,

- block: None,

- traits_from_clauses: traits_in_scope.into_boxed_slice(),

- env,

- })

+ TraitEnvironment::new(krate, None, traits_in_scope.into_boxed_slice(), env)

}

/// Resolve the where clause(s) of an item with generics.

diff --git a/crates/hir-ty/src/mir.rs b/crates/hir-ty/src/mir.rs
index 2e6fe59d3b..f1795e71d9 100644
--- a/crates/hir-ty/src/mir.rs
+++ b/crates/hir-ty/src/mir.rs

@@ -40,7 +40,6 @@ pub use monomorphization::{

use rustc_hash::FxHashMap;

use smallvec::{smallvec, SmallVec};

use stdx::{impl_from, never};

-use triomphe::Arc;

use super::consteval::{intern_const_scalar, try_const_usize};

@@ -147,7 +146,7 @@ impl<V, T> ProjectionElem<V, T> {

base = normalize(

db,

// FIXME: we should get this from caller

- Arc::new(TraitEnvironment::empty(krate)),

+ TraitEnvironment::empty(krate),

base,

);

}

diff --git a/crates/hir-ty/src/traits.rs b/crates/hir-ty/src/traits.rs
index 467b94a266..b6bc76bc98 100644
--- a/crates/hir-ty/src/traits.rs
+++ b/crates/hir-ty/src/traits.rs

@@ -48,18 +48,32 @@ pub struct TraitEnvironment {

pub krate: CrateId,

pub block: Option<BlockId>,

// FIXME make this a BTreeMap

- pub(crate) traits_from_clauses: Box<[(Ty, TraitId)]>,

+ traits_from_clauses: Box<[(Ty, TraitId)]>,

pub env: chalk_ir::Environment<Interner>,

}

impl TraitEnvironment {

- pub fn empty(krate: CrateId) -> Self {

- TraitEnvironment {

+ pub fn empty(krate: CrateId) -> Arc<Self> {

+ Arc::new(TraitEnvironment {

krate,

block: None,

traits_from_clauses: Box::default(),

env: chalk_ir::Environment::new(Interner),

- }

+ })

+ }

+ pub fn new(

+ krate: CrateId,

+ block: Option<BlockId>,

+ traits_from_clauses: Box<[(Ty, TraitId)]>,

+ env: chalk_ir::Environment<Interner>,

+ ) -> Arc<Self> {

+ Arc::new(TraitEnvironment { krate, block, traits_from_clauses, env })

+ }

+ // pub fn with_block(self: &mut Arc<Self>, block: BlockId) {

+ pub fn with_block(this: &mut Arc<Self>, block: BlockId) {

+ Arc::make_mut(this).block = Some(block);

}

pub fn traits_in_scope_from_clauses(&self, ty: Ty) -> impl Iterator<Item = TraitId> + '_ {

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 5137bff055..ca838c7a51 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs

@@ -3564,10 +3564,9 @@ impl TraitRef {

resolver: &Resolver,

trait_ref: hir_ty::TraitRef,

) -> TraitRef {

- let env = resolver.generic_def().map_or_else(

- || Arc::new(TraitEnvironment::empty(resolver.krate())),

- |d| db.trait_environment(d),

- );

+ let env = resolver

+ .generic_def()

+ .map_or_else(|| TraitEnvironment::empty(resolver.krate()), |d| db.trait_environment(d));

TraitRef { env, trait_ref }

}

@@ -3707,15 +3706,14 @@ impl Type {

resolver: &Resolver,

ty: Ty,

) -> Type {

- let environment = resolver.generic_def().map_or_else(

- || Arc::new(TraitEnvironment::empty(resolver.krate())),

- |d| db.trait_environment(d),

- );

+ let environment = resolver

+ .generic_def()

+ .map_or_else(|| TraitEnvironment::empty(resolver.krate()), |d| db.trait_environment(d));

Type { env: environment, ty }

}

pub(crate) fn new_for_crate(krate: CrateId, ty: Ty) -> Type {

- Type { env: Arc::new(TraitEnvironment::empty(krate)), ty }

+ Type { env: TraitEnvironment::empty(krate), ty }

}

pub fn reference(inner: &Type, m: Mutability) -> Type {

@@ -3731,10 +3729,9 @@ impl Type {

fn new(db: &dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty) -> Type {

let resolver = lexical_env.resolver(db.upcast());

- let environment = resolver.generic_def().map_or_else(

- || Arc::new(TraitEnvironment::empty(resolver.krate())),

- |d| db.trait_environment(d),

- );

+ let environment = resolver

+ .generic_def()

+ .map_or_else(|| TraitEnvironment::empty(resolver.krate()), |d| db.trait_environment(d));

Type { env: environment, ty }

}

@@ -4304,10 +4301,10 @@ impl Type {

let canonical = hir_ty::replace_errors_with_variables(&self.ty);

let krate = scope.krate();

- let environment = scope.resolver().generic_def().map_or_else(

- || Arc::new(TraitEnvironment::empty(krate.id)),

- |d| db.trait_environment(d),

- );

+ let environment = scope

+ .resolver()

+ .generic_def()

+ .map_or_else(|| TraitEnvironment::empty(krate.id), |d| db.trait_environment(d));

method_resolution::iterate_method_candidates_dyn(

&canonical,

@@ -4361,10 +4358,10 @@ impl Type {

let canonical = hir_ty::replace_errors_with_variables(&self.ty);

let krate = scope.krate();

- let environment = scope.resolver().generic_def().map_or_else(

- || Arc::new(TraitEnvironment::empty(krate.id)),

- |d| db.trait_environment(d),

- );

+ let environment = scope

+ .resolver()

+ .generic_def()

+ .map_or_else(|| TraitEnvironment::empty(krate.id), |d| db.trait_environment(d));

method_resolution::iterate_path_candidates(

&canonical,