| //! Things relevant to the next trait solver. |
| |
| // Note: in interned types defined in this module, we generally treat the lifetime as advisory |
| // and transmute it as needed. This is because no real memory unsafety can be caused from an |
| // incorrect lifetime here. |
| |
| pub mod abi; |
| mod allocation; |
| mod binder; |
| mod consts; |
| mod def_id; |
| pub mod fold; |
| pub mod format_proof_tree; |
| pub mod fulfill; |
| mod generic_arg; |
| pub mod generics; |
| pub mod infer; |
| pub(crate) mod inspect; |
| pub mod interner; |
| mod ir_print; |
| pub mod normalize; |
| pub mod obligation_ctxt; |
| mod opaques; |
| pub mod predicate; |
| mod region; |
| mod solver; |
| mod structural_normalize; |
| mod ty; |
| pub mod util; |
| |
| use std::{mem::ManuallyDrop, sync::OnceLock}; |
| |
| pub use allocation::*; |
| pub use binder::*; |
| pub use consts::*; |
| pub use def_id::*; |
| pub use generic_arg::*; |
| pub use interner::*; |
| pub use opaques::*; |
| pub use predicate::*; |
| pub use region::*; |
| use rustc_type_ir::MayBeErased; |
| pub use solver::*; |
| pub use ty::*; |
| |
| use crate::db::HirDatabase; |
| pub use crate::lower::ImplTraitIdx; |
| pub use rustc_ast_ir::Mutability; |
| |
| pub type Binder<'db, T> = rustc_type_ir::Binder<DbInterner<'db>, T>; |
| pub type EarlyBinder<'db, T> = rustc_type_ir::EarlyBinder<DbInterner<'db>, T>; |
| pub type Unnormalized<'db, T> = rustc_type_ir::Unnormalized<DbInterner<'db>, T>; |
| pub type Canonical<'db, T> = rustc_type_ir::Canonical<DbInterner<'db>, T>; |
| pub type CanonicalVarValues<'db> = rustc_type_ir::CanonicalVarValues<DbInterner<'db>>; |
| pub type CanonicalVarKind<'db> = rustc_type_ir::CanonicalVarKind<DbInterner<'db>>; |
| pub type CanonicalQueryInput<'db, V> = rustc_type_ir::CanonicalQueryInput<DbInterner<'db>, V>; |
| pub type AliasTy<'db> = rustc_type_ir::AliasTy<DbInterner<'db>>; |
| pub type FnSig<'db> = rustc_type_ir::FnSig<DbInterner<'db>>; |
| pub type PolyFnSig<'db> = Binder<'db, rustc_type_ir::FnSig<DbInterner<'db>>>; |
| pub type TypingMode<'db, S = MayBeErased> = rustc_type_ir::TypingMode<DbInterner<'db>, S>; |
| pub type TypeError<'db> = rustc_type_ir::error::TypeError<DbInterner<'db>>; |
| pub type QueryResult<'db> = rustc_type_ir::solve::QueryResult<DbInterner<'db>>; |
| pub type FxIndexMap<K, V> = rustc_type_ir::data_structures::IndexMap<K, V>; |
| |
| pub struct DefaultTypes<'db> { |
| pub usize: Ty<'db>, |
| pub u8: Ty<'db>, |
| pub u16: Ty<'db>, |
| pub u32: Ty<'db>, |
| pub u64: Ty<'db>, |
| pub u128: Ty<'db>, |
| pub isize: Ty<'db>, |
| pub i8: Ty<'db>, |
| pub i16: Ty<'db>, |
| pub i32: Ty<'db>, |
| pub i64: Ty<'db>, |
| pub i128: Ty<'db>, |
| pub f16: Ty<'db>, |
| pub f32: Ty<'db>, |
| pub f64: Ty<'db>, |
| pub f128: Ty<'db>, |
| pub unit: Ty<'db>, |
| pub bool: Ty<'db>, |
| pub char: Ty<'db>, |
| pub str: Ty<'db>, |
| pub never: Ty<'db>, |
| pub error: Ty<'db>, |
| /// `&'static str` |
| pub static_str_ref: Ty<'db>, |
| /// `[u8]` |
| pub u8_slice: Ty<'db>, |
| /// `&'static [u8]` |
| pub static_u8_slice: Ty<'db>, |
| /// `*mut ()` |
| pub mut_unit_ptr: Ty<'db>, |
| pub dyn_trait_dummy_self: Ty<'db>, |
| } |
| |
| pub struct DefaultConsts<'db> { |
| pub error: Const<'db>, |
| pub u8_values: [Const<'db>; 256], |
| } |
| |
| pub struct DefaultRegions<'db> { |
| pub error: Region<'db>, |
| pub statik: Region<'db>, |
| pub erased: Region<'db>, |
| } |
| |
| pub struct DefaultEmpty<'db> { |
| pub tys: Tys<'db>, |
| pub generic_args: GenericArgs<'db>, |
| pub bound_var_kinds: BoundVarKinds<'db>, |
| pub canonical_vars: CanonicalVarKinds<'db>, |
| pub variances: VariancesOf<'db>, |
| pub pat_list: PatList<'db>, |
| pub predefined_opaques: PredefinedOpaques<'db>, |
| pub def_ids: SolverDefIds<'db>, |
| pub bound_existential_predicates: BoundExistentialPredicates<'db>, |
| pub clauses: Clauses<'db>, |
| pub region_assumptions: RegionAssumptions<'db>, |
| pub consts: Consts<'db>, |
| pub projection: crate::mir::Projection<'db>, |
| } |
| |
| pub struct DefaultAny<'db> { |
| pub types: DefaultTypes<'db>, |
| pub consts: DefaultConsts<'db>, |
| pub regions: DefaultRegions<'db>, |
| pub empty: DefaultEmpty<'db>, |
| /// `[Invariant]` |
| pub one_invariant: VariancesOf<'db>, |
| /// `[Covariant]` |
| pub one_covariant: VariancesOf<'db>, |
| /// `for<'env>` |
| pub coroutine_captures_by_ref_bound_var_kinds: BoundVarKinds<'db>, |
| } |
| |
| impl std::fmt::Debug for DefaultAny<'_> { |
| fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| f.debug_struct("DefaultAny").finish_non_exhaustive() |
| } |
| } |
| |
| #[inline] |
| pub fn default_types<'db>(db: &'db dyn HirDatabase) -> &'db DefaultAny<'db> { |
| static TYPES: OnceLock<DefaultAny<'static>> = OnceLock::new(); |
| |
| let interner = DbInterner::new_no_crate(db); |
| TYPES.get_or_init(|| { |
| let create_ty = |kind| { |
| let ty = Ty::new(interner, kind); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_const = |kind| { |
| let ty = Const::new(interner, kind); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_region = |kind| { |
| let ty = Region::new(interner, kind); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_generic_args = |slice| { |
| let ty = GenericArgs::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_bound_var_kinds = |slice| { |
| let ty = BoundVarKinds::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_canonical_vars = |slice| { |
| let ty = CanonicalVarKinds::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_variances_of = |slice| { |
| let ty = VariancesOf::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_pat_list = |slice| { |
| let ty = PatList::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_predefined_opaques = |slice| { |
| let ty = PredefinedOpaques::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_solver_def_ids = |slice| { |
| let ty = SolverDefIds::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_bound_existential_predicates = |slice| { |
| let ty = BoundExistentialPredicates::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_clauses = |slice| { |
| let ty = Clauses::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_region_assumptions = |slice| { |
| let ty = RegionAssumptions::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_tys = |slice| { |
| let ty = Tys::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_consts = |slice| { |
| let ty = Consts::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let ty = ManuallyDrop::new(ty.store()); |
| ty.as_ref() |
| }; |
| let create_projection = |slice| { |
| let it = crate::mir::Projection::new_from_slice(slice); |
| // We need to increase the refcount (forever), so that the types won't be freed. |
| let it = ManuallyDrop::new(it.store()); |
| it.as_ref() |
| }; |
| |
| let str = create_ty(TyKind::Str); |
| let statik = create_region(RegionKind::ReStatic); |
| let empty_tys = create_tys(&[]); |
| let unit = create_ty(TyKind::Tuple(empty_tys)); |
| let u8 = create_ty(TyKind::Uint(rustc_ast_ir::UintTy::U8)); |
| let u8_slice = create_ty(TyKind::Slice(u8)); |
| let static_u8_slice = create_ty(TyKind::Ref(statik, u8_slice, Mutability::Not)); |
| DefaultAny { |
| types: DefaultTypes { |
| usize: create_ty(TyKind::Uint(rustc_ast_ir::UintTy::Usize)), |
| u8, |
| u16: create_ty(TyKind::Uint(rustc_ast_ir::UintTy::U16)), |
| u32: create_ty(TyKind::Uint(rustc_ast_ir::UintTy::U32)), |
| u64: create_ty(TyKind::Uint(rustc_ast_ir::UintTy::U64)), |
| u128: create_ty(TyKind::Uint(rustc_ast_ir::UintTy::U128)), |
| isize: create_ty(TyKind::Int(rustc_ast_ir::IntTy::Isize)), |
| i8: create_ty(TyKind::Int(rustc_ast_ir::IntTy::I8)), |
| i16: create_ty(TyKind::Int(rustc_ast_ir::IntTy::I16)), |
| i32: create_ty(TyKind::Int(rustc_ast_ir::IntTy::I32)), |
| i64: create_ty(TyKind::Int(rustc_ast_ir::IntTy::I64)), |
| i128: create_ty(TyKind::Int(rustc_ast_ir::IntTy::I128)), |
| f16: create_ty(TyKind::Float(rustc_ast_ir::FloatTy::F16)), |
| f32: create_ty(TyKind::Float(rustc_ast_ir::FloatTy::F32)), |
| f64: create_ty(TyKind::Float(rustc_ast_ir::FloatTy::F64)), |
| f128: create_ty(TyKind::Float(rustc_ast_ir::FloatTy::F128)), |
| unit, |
| bool: create_ty(TyKind::Bool), |
| char: create_ty(TyKind::Char), |
| str, |
| never: create_ty(TyKind::Never), |
| error: create_ty(TyKind::Error(ErrorGuaranteed)), |
| static_str_ref: create_ty(TyKind::Ref(statik, str, rustc_ast_ir::Mutability::Not)), |
| u8_slice, |
| static_u8_slice, |
| mut_unit_ptr: create_ty(TyKind::RawPtr(unit, rustc_ast_ir::Mutability::Mut)), |
| // This type must not appear anywhere except here. |
| dyn_trait_dummy_self: create_ty(TyKind::Infer(rustc_type_ir::InferTy::FreshTy(0))), |
| }, |
| consts: DefaultConsts { |
| error: create_const(ConstKind::Error(ErrorGuaranteed)), |
| u8_values: std::array::from_fn(|u8_value| { |
| create_const(ConstKind::Value(ValueConst { |
| ty: u8, |
| value: ValTree::new(ValTreeKind::Leaf(ScalarInt::from(u8_value as u8))), |
| })) |
| }), |
| }, |
| regions: DefaultRegions { |
| error: create_region(RegionKind::ReError(ErrorGuaranteed)), |
| statik, |
| erased: create_region(RegionKind::ReErased), |
| }, |
| empty: DefaultEmpty { |
| tys: empty_tys, |
| generic_args: create_generic_args(&[]), |
| bound_var_kinds: create_bound_var_kinds(&[]), |
| canonical_vars: create_canonical_vars(&[]), |
| variances: create_variances_of(&[]), |
| pat_list: create_pat_list(&[]), |
| predefined_opaques: create_predefined_opaques(&[]), |
| def_ids: create_solver_def_ids(&[]), |
| bound_existential_predicates: create_bound_existential_predicates(&[]), |
| clauses: create_clauses(&[]), |
| region_assumptions: create_region_assumptions(&[]), |
| consts: create_consts(&[]), |
| projection: create_projection(&[]), |
| }, |
| one_invariant: create_variances_of(&[rustc_type_ir::Variance::Invariant]), |
| one_covariant: create_variances_of(&[rustc_type_ir::Variance::Covariant]), |
| coroutine_captures_by_ref_bound_var_kinds: create_bound_var_kinds(&[ |
| BoundVariableKind::Region(BoundRegionKind::ClosureEnv), |
| ]), |
| } |
| }) |
| } |
