-mod builder;

-mod chalk_db;

-mod chalk_ext;

-mod interner;

-mod lower_nextsolver;

-mod mapping;

-mod tls;

-mod consteval_chalk;

-use chalk_ir::{

- VariableKinds,

- fold::{Shift, TypeFoldable},

- interner::HasInterner,

-};

-use hir_def::{CallableDefId, GeneralConstId, TypeOrConstParamId, hir::ExprId, type_ref::Rawness};

-use la_arena::{Arena, Idx};

- TypeSuperVisitable, TypeVisitableExt, UpcastFrom,

-#[cfg(not(debug_assertions))]

-use crate::next_solver::ErrorGuaranteed;

- generics::Generics,

- DbInterner,

- mapping::{ChalkToNextSolver, NextSolverToChalk, convert_ty_for_result},

-pub use builder::{ParamKind, TyBuilder};

-pub use chalk_ext::*;

-pub use interner::Interner;

-pub use lower::{ImplTraitLoweringMode, ParamLoweringMode, TyDefId, ValueTyDefId, diagnostics::*};

-pub use lower_nextsolver::{

- LifetimeElisionKind, TyLoweringContext, associated_type_shorthand_candidates,

-};

-pub use mapping::{

- ToChalk, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx,

- lt_from_placeholder_idx, lt_to_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,

- to_foreign_def_id, to_placeholder_idx, to_placeholder_idx_no_index,

-pub use variance::Variance;

-

-use chalk_ir::{AdtId, BoundVar, DebruijnIndex, Safety, Scalar};

-

-pub(crate) type ForeignDefId = chalk_ir::ForeignDefId<Interner>;

-pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;

-pub(crate) type FnDefId = chalk_ir::FnDefId<Interner>;

-pub(crate) type ClosureId = chalk_ir::ClosureId<Interner>;

-pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;

-pub(crate) type PlaceholderIndex = chalk_ir::PlaceholderIndex;

-

-pub(crate) type CanonicalVarKinds = chalk_ir::CanonicalVarKinds<Interner>;

-

-pub(crate) type VariableKind = chalk_ir::VariableKind<Interner>;

-/// Represents generic parameters and an item bound by them. When the item has parent, the binders

-/// also contain the generic parameters for its parent. See chalk's documentation for details.

-///

-/// One thing to keep in mind when working with `Binders` (and `Substitution`s, which represent

-/// generic arguments) in rust-analyzer is that the ordering within *is* significant - the generic

-/// parameters/arguments for an item MUST come before those for its parent. This is to facilitate

-/// the integration with chalk-solve, which mildly puts constraints as such. See #13335 for its

-/// motivation in detail.

-pub(crate) type Binders<T> = chalk_ir::Binders<T>;

-/// Interned list of generic arguments for an item. When an item has parent, the `Substitution` for

-/// it contains generic arguments for both its parent and itself. See chalk's documentation for

-/// details.

-///

-/// See `Binders` for the constraint on the ordering.

-pub(crate) type Substitution = chalk_ir::Substitution<Interner>;

-pub(crate) type GenericArg = chalk_ir::GenericArg<Interner>;

-pub(crate) type GenericArgData = chalk_ir::GenericArgData<Interner>;

-

-pub(crate) type Ty = chalk_ir::Ty<Interner>;

-pub type TyKind = chalk_ir::TyKind<Interner>;

-pub(crate) type TypeFlags = chalk_ir::TypeFlags;

-pub(crate) type DynTy = chalk_ir::DynTy<Interner>;

-pub(crate) type FnPointer = chalk_ir::FnPointer<Interner>;

-pub(crate) use chalk_ir::FnSubst; // a re-export so we don't lose the tuple constructor

-

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

-

-pub(crate) type ProjectionTy = chalk_ir::ProjectionTy<Interner>;

-pub(crate) type OpaqueTy = chalk_ir::OpaqueTy<Interner>;

-

-pub(crate) type Lifetime = chalk_ir::Lifetime<Interner>;

-pub(crate) type LifetimeData = chalk_ir::LifetimeData<Interner>;

-pub(crate) type LifetimeOutlives = chalk_ir::LifetimeOutlives<Interner>;

-

-pub(crate) type ConstValue = chalk_ir::ConstValue<Interner>;

-

-pub(crate) type Const = chalk_ir::Const<Interner>;

-pub(crate) type ConstData = chalk_ir::ConstData<Interner>;

-pub(crate) type ConcreteConst = chalk_ir::ConcreteConst<Interner>;

-

-pub(crate) type TraitRef = chalk_ir::TraitRef<Interner>;

-pub(crate) type QuantifiedWhereClause = Binders<WhereClause>;

-pub(crate) type Canonical<T> = chalk_ir::Canonical<T>;

-

-pub(crate) type ChalkTraitId = chalk_ir::TraitId<Interner>;

-pub(crate) type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;

-

-pub(crate) type FnSig = chalk_ir::FnSig<Interner>;

-

-pub(crate) type InEnvironment<T> = chalk_ir::InEnvironment<T>;

-pub type AliasEq = chalk_ir::AliasEq<Interner>;

-pub type WhereClause = chalk_ir::WhereClause<Interner>;

-

-pub(crate) type DomainGoal = chalk_ir::DomainGoal<Interner>;

-pub(crate) type Goal = chalk_ir::Goal<Interner>;

-

-pub(crate) type CanonicalVarKind = chalk_ir::CanonicalVarKind<Interner>;

-pub(crate) type GoalData = chalk_ir::GoalData<Interner>;

-pub(crate) type ProgramClause = chalk_ir::ProgramClause<Interner>;

- pub fn vtable_ty(&self, id: usize) -> Result<crate::next_solver::Ty<'db>, MirEvalError<'db>> {

-// FIXME(next-solver): add a lifetime to this

-/// A concrete constant value

-#[derive(Debug, Clone, PartialEq, Eq)]

-pub enum ConstScalar {

- Bytes(Box<[u8]>, MemoryMap<'static>),

- // FIXME: this is a hack to get around chalk not being able to represent unevaluatable

- // constants

- UnevaluatedConst(GeneralConstId, Substitution),

- /// Case of an unknown value that rustc might know but we don't

- // FIXME: this is a hack to get around chalk not being able to represent unevaluatable

- // constants

- // https://github.com/rust-lang/rust-analyzer/pull/8813#issuecomment-840679177

- // https://rust-lang.zulipchat.com/#narrow/stream/144729-wg-traits/topic/Handling.20non.20evaluatable.20constants'.20equality/near/238386348

- Unknown,

-}

-

-impl Hash for ConstScalar {

- fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

- core::mem::discriminant(self).hash(state);

- if let ConstScalar::Bytes(b, _) = self {

- b.hash(state)

- }

- }

-}

-

-/// A concrete constant value

-#[derive(Debug, Clone, PartialEq, Eq)]

-pub enum ConstScalarNs<'db> {

- Bytes(Box<[u8]>, MemoryMap<'db>),

- // FIXME: this is a hack to get around chalk not being able to represent unevaluatable

- // constants

- UnevaluatedConst(GeneralConstId, Substitution),

- /// Case of an unknown value that rustc might know but we don't

- // FIXME: this is a hack to get around chalk not being able to represent unevaluatable

- // constants

- // https://github.com/rust-lang/rust-analyzer/pull/8813#issuecomment-840679177

- // https://rust-lang.zulipchat.com/#narrow/stream/144729-wg-traits/topic/Handling.20non.20evaluatable.20constants'.20equality/near/238386348

- Unknown,

-}

-

-impl Hash for ConstScalarNs<'_> {

- fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

- core::mem::discriminant(self).hash(state);

- if let ConstScalarNs::Bytes(b, _) = self {

- b.hash(state)

- }

- }

-}

-

-pub(crate) fn wrap_empty_binders<T>(value: T) -> Binders<T>

-where

- T: TypeFoldable<Interner> + HasInterner<Interner = Interner>,

-{

- Binders::empty(Interner, value.shifted_in_from(Interner, DebruijnIndex::ONE))

-}

-

-pub(crate) fn make_single_type_binders<T: HasInterner<Interner = Interner>>(

- value: T,

-) -> Binders<T> {

- Binders::new(

- chalk_ir::VariableKinds::from_iter(

- Interner,

- std::iter::once(chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General)),

- ),

- value,

- )

-}

-

-pub(crate) fn make_binders<T: HasInterner<Interner = Interner>>(

- db: &dyn HirDatabase,

- generics: &Generics,

- value: T,

-) -> Binders<T> {

- Binders::new(variable_kinds_from_iter(db, generics.iter_id()), value)

-}

-

-pub(crate) fn variable_kinds_from_iter(

- db: &dyn HirDatabase,

- iter: impl Iterator<Item = hir_def::GenericParamId>,

-) -> VariableKinds<Interner> {

- VariableKinds::from_iter(

- Interner,

- iter.map(|x| match x {

- hir_def::GenericParamId::ConstParamId(id) => {

- chalk_ir::VariableKind::Const(db.const_param_ty(id))

- }

- hir_def::GenericParamId::TypeParamId(_) => {

- chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General)

- }

- hir_def::GenericParamId::LifetimeParamId(_) => chalk_ir::VariableKind::Lifetime,

- }),

- )

-}

-

-// FIXME: get rid of this, just replace it by FnPointer

-/// A function signature as seen by type inference: Several parameter types and

-/// one return type.

-#[derive(Clone, PartialEq, Eq, Debug)]

-pub struct CallableSig {

- params_and_return: Arc<[Ty]>,

- is_varargs: bool,

- safety: Safety,

- abi: FnAbi,

-}

-

-has_interner!(CallableSig);

-

-/// A polymorphic function signature.

-pub type PolyFnSig = Binders<CallableSig>;

-

-impl CallableSig {

- pub fn from_params_and_return(

- params: impl Iterator<Item = Ty>,

- ret: Ty,

- is_varargs: bool,

- safety: Safety,

- abi: FnAbi,

- ) -> CallableSig {

- let mut params_and_return = Vec::with_capacity(params.size_hint().0 + 1);

- params_and_return.extend(params);

- params_and_return.push(ret);

- CallableSig { params_and_return: params_and_return.into(), is_varargs, safety, abi }

- }

-

- pub fn from_def(db: &dyn HirDatabase, def: FnDefId, substs: &Substitution) -> CallableSig {

- let callable_def = ToChalk::from_chalk(db, def);

- let interner = DbInterner::new_with(db, None, None);

- let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);

- let sig = db.callable_item_signature(callable_def);

- sig.instantiate(interner, args).skip_binder().to_chalk(interner)

- }

- pub fn from_fn_ptr(fn_ptr: &FnPointer) -> CallableSig {

- CallableSig {

- // FIXME: what to do about lifetime params? -> return PolyFnSig

- params_and_return: Arc::from_iter(

- fn_ptr

- .substitution

- .clone()

- .shifted_out_to(Interner, DebruijnIndex::ONE)

- .expect("unexpected lifetime vars in fn ptr")

- .0

- .as_slice(Interner)

- .iter()

- .map(|arg| arg.assert_ty_ref(Interner).clone()),

- ),

- is_varargs: fn_ptr.sig.variadic,

- safety: fn_ptr.sig.safety,

- abi: fn_ptr.sig.abi,

- }

- }

- pub fn from_fn_sig_and_header<'db>(

- interner: DbInterner<'db>,

- sig: crate::next_solver::Binder<'db, rustc_type_ir::FnSigTys<DbInterner<'db>>>,

- header: rustc_type_ir::FnHeader<DbInterner<'db>>,

- ) -> CallableSig {

- CallableSig {

- // FIXME: what to do about lifetime params? -> return PolyFnSig

- params_and_return: Arc::from_iter(

- sig.skip_binder()

- .inputs_and_output

- .iter()

- .map(|t| convert_ty_for_result(interner, t)),

- ),

- is_varargs: header.c_variadic,

- safety: match header.safety {

- next_solver::abi::Safety::Safe => chalk_ir::Safety::Safe,

- next_solver::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,

- },

- abi: header.abi,

- }

- }

-

- pub fn to_fn_ptr(&self) -> FnPointer {

- FnPointer {

- num_binders: 0,

- sig: FnSig { abi: self.abi, safety: self.safety, variadic: self.is_varargs },

- substitution: FnSubst(Substitution::from_iter(

- Interner,

- self.params_and_return.iter().cloned(),

- )),

- }

- }

-

- pub fn abi(&self) -> FnAbi {

- self.abi

- }

-

- pub fn params(&self) -> &[Ty] {

- &self.params_and_return[0..self.params_and_return.len() - 1]

- }

-

- pub fn ret(&self) -> &Ty {

- &self.params_and_return[self.params_and_return.len() - 1]

- }

-}

-

-impl TypeFoldable<Interner> for CallableSig {

- fn try_fold_with<E>(

- self,

- folder: &mut dyn chalk_ir::fold::FallibleTypeFolder<Interner, Error = E>,

- outer_binder: DebruijnIndex,

- ) -> Result<Self, E> {

- let vec = self.params_and_return.to_vec();

- let folded = vec.try_fold_with(folder, outer_binder)?;

- Ok(CallableSig {

- params_and_return: folded.into(),

- is_varargs: self.is_varargs,

- safety: self.safety,

- abi: self.abi,

- })

- }

-}

-

-pub enum ImplTraitId {

- ReturnTypeImplTrait(hir_def::FunctionId, ImplTraitIdx), // FIXME(next-solver): Should be crate::nextsolver::ImplTraitIdx.

- TypeAliasImplTrait(hir_def::TypeAliasId, ImplTraitIdx),

- AsyncBlockTypeImplTrait(hir_def::DefWithBodyId, ExprId),

-}

-

-#[derive(PartialEq, Eq, Debug, Hash)]

-pub struct ImplTraits {

- pub(crate) impl_traits: Arena<ImplTrait>,

-}

-

-has_interner!(ImplTraits);

-

-#[derive(PartialEq, Eq, Debug, Hash)]

-pub struct ImplTrait {

- pub(crate) bounds: Binders<Vec<QuantifiedWhereClause>>,

-}

-

-pub type ImplTraitIdx = Idx<ImplTrait>;

-

-pub fn static_lifetime() -> Lifetime {

- LifetimeData::Static.intern(Interner)

-}

-

-pub fn error_lifetime() -> Lifetime {

- LifetimeData::Error.intern(Interner)

-}

-

-pub(crate) fn fold_free_vars<T: HasInterner<Interner = Interner> + TypeFoldable<Interner>>(

- t: T,

- for_ty: impl FnMut(BoundVar, DebruijnIndex) -> Ty,

- for_const: impl FnMut(Ty, BoundVar, DebruijnIndex) -> Const,

-) -> T {

- use chalk_ir::fold::TypeFolder;

-

- #[derive(chalk_derive::FallibleTypeFolder)]

- #[has_interner(Interner)]

- struct FreeVarFolder<

- F1: FnMut(BoundVar, DebruijnIndex) -> Ty,

- F2: FnMut(Ty, BoundVar, DebruijnIndex) -> Const,

- >(F1, F2);

- impl<F1: FnMut(BoundVar, DebruijnIndex) -> Ty, F2: FnMut(Ty, BoundVar, DebruijnIndex) -> Const>

- TypeFolder<Interner> for FreeVarFolder<F1, F2>

- {

- fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner> {

- self

- }

-

- fn interner(&self) -> Interner {

- Interner

- }

-

- fn fold_free_var_ty(&mut self, bound_var: BoundVar, outer_binder: DebruijnIndex) -> Ty {

- self.0(bound_var, outer_binder)

- }

-

- fn fold_free_var_const(

- &mut self,

- ty: Ty,

- bound_var: BoundVar,

- outer_binder: DebruijnIndex,

- ) -> Const {

- self.1(ty, bound_var, outer_binder)

- }

- }

- t.fold_with(&mut FreeVarFolder(for_ty, for_const), DebruijnIndex::INNERMOST)

-pub fn replace_errors_with_variables<'db, T>(

- interner: DbInterner<'db>,

- t: &T,

-) -> crate::next_solver::Canonical<'db, T>

- vars: Vec<crate::next_solver::CanonicalVarKind<'db>>,

- fn try_fold_binder<T>(

- &mut self,

- t: crate::next_solver::Binder<'db, T>,

- ) -> Result<crate::next_solver::Binder<'db, T>, Self::Error>

- fn try_fold_ty(

- &mut self,

- t: crate::next_solver::Ty<'db>,

- ) -> Result<crate::next_solver::Ty<'db>, Self::Error> {

- let error = || Ok(crate::next_solver::Ty::new_error(self.interner, ErrorGuaranteed));

- crate::next_solver::TyKind::Error(_) => {

- self.vars.push(crate::next_solver::CanonicalVarKind::Ty {

- Ok(crate::next_solver::Ty::new_bound(

- crate::next_solver::BoundTy {

- var,

- kind: crate::next_solver::BoundTyKind::Anon,

- },

- crate::next_solver::TyKind::Infer(_) => error(),

- crate::next_solver::TyKind::Bound(index, _) if index > self.binder => error(),

- fn try_fold_const(

- &mut self,

- ct: crate::next_solver::Const<'db>,

- ) -> Result<crate::next_solver::Const<'db>, Self::Error> {

- let error = || Ok(crate::next_solver::Const::error(self.interner));

- crate::next_solver::ConstKind::Error(_) => {

- self.vars.push(crate::next_solver::CanonicalVarKind::Const(

- rustc_type_ir::UniverseIndex::ZERO,

- ));

- Ok(crate::next_solver::Const::new_bound(

- self.interner,

- self.binder,

- crate::next_solver::BoundConst { var },

- ))

- crate::next_solver::ConstKind::Infer(_) => error(),

- crate::next_solver::ConstKind::Bound(index, _) if index > self.binder => error(),

- fn try_fold_region(

- &mut self,

- region: crate::next_solver::Region<'db>,

- ) -> Result<crate::next_solver::Region<'db>, Self::Error> {

- let error = || Ok(crate::next_solver::Region::error(self.interner));

- crate::next_solver::RegionKind::ReError(_) => {

- self.vars.push(crate::next_solver::CanonicalVarKind::Region(

- rustc_type_ir::UniverseIndex::ZERO,

- ));

- Ok(crate::next_solver::Region::new_bound(

- crate::next_solver::BoundRegion {

- var,

- kind: crate::next_solver::BoundRegionKind::Anon,

- },

- crate::next_solver::RegionKind::ReVar(_) => error(),

- crate::next_solver::RegionKind::ReBound(index, _) if index > self.binder => error(),

- crate::next_solver::Canonical {

- variables: crate::next_solver::CanonicalVars::new_from_iter(interner, error_replacer.vars),

- self_ty: crate::next_solver::Ty<'db>,

-) -> Option<(FnTrait, crate::next_solver::PolyFnSig<'db>)> {

- let b = TyBuilder::trait_ref(db, fn_once_trait);

- if b.remaining() != 2 {

- return None;

- }

- let trait_ref = crate::next_solver::TraitRef::new(table.interner(), fn_once_trait.into(), args);

- let projection = crate::next_solver::Ty::new_alias(

- crate::next_solver::AliasTy::new(table.interner(), output_assoc_type.into(), args),

- let pred = crate::next_solver::Predicate::upcast_from(trait_ref, table.interner());

- let trait_ref =

- crate::next_solver::TraitRef::new(table.interner(), fn_x_trait.into(), args);

- .try_obligation(crate::next_solver::Predicate::upcast_from(

- trait_ref,

- table.interner(),

- ))

- let crate::next_solver::TyKind::Tuple(params) = args_ty.kind() else {

- let inputs_and_output = crate::next_solver::Tys::new_from_iter(

- crate::next_solver::Binder::dummy(crate::next_solver::FnSig {

- safety: crate::next_solver::abi::Safety::Safe,

- fn visit_ty(&mut self, ty: crate::next_solver::Ty<'db>) -> Self::Result {

- if let crate::next_solver::TyKind::Param(param) = ty.kind() {

- fn visit_const(&mut self, konst: crate::next_solver::Const<'db>) -> Self::Result {

- if let crate::next_solver::ConstKind::Param(param) = konst.kind() {

- konst: crate::next_solver::Const<'db>,