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

   1 //! The home of `HirDatabase`, which is the Salsa database containing all the
   2 //! type inference-related queries.
   3
   4 use std::sync::Arc;
   5
   6 use base_db::{impl_intern_key, salsa, CrateId, Upcast};
   7 use hir_def::{
   8     db::DefDatabase,
   9     expr::ExprId,
  10     layout::{Layout, LayoutError, TargetDataLayout},
  11     AdtId, BlockId, ConstId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId, GenericDefId,
  12     ImplId, LifetimeParamId, LocalFieldId, TypeOrConstParamId, VariantId,
  13 };
  14 use la_arena::ArenaMap;
  15 use smallvec::SmallVec;
  16
  17 use crate::{
  18     chalk_db,
  19     consteval::{ComputedExpr, ConstEvalError},
  20     method_resolution::{InherentImpls, TraitImpls, TyFingerprint},
  21     Binders, CallableDefId, FnDefId, GenericArg, ImplTraitId, InferenceResult, Interner, PolyFnSig,
  22     QuantifiedWhereClause, ReturnTypeImplTraits, Substitution, TraitRef, Ty, TyDefId, ValueTyDefId,
  23 };
  24 use hir_expand::name::Name;
  25
  26 #[salsa::query_group(HirDatabaseStorage)]
  27 pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
  28     #[salsa::invoke(infer_wait)]
  29     #[salsa::transparent]
  30     fn infer(&self, def: DefWithBodyId) -> Arc<InferenceResult>;
  31
  32     #[salsa::invoke(crate::infer::infer_query)]
  33     fn infer_query(&self, def: DefWithBodyId) -> Arc<InferenceResult>;
  34
  35     #[salsa::invoke(crate::lower::ty_query)]
  36     #[salsa::cycle(crate::lower::ty_recover)]
  37     fn ty(&self, def: TyDefId) -> Binders<Ty>;
  38
  39     #[salsa::invoke(crate::lower::value_ty_query)]
  40     fn value_ty(&self, def: ValueTyDefId) -> Binders<Ty>;
  41
  42     #[salsa::invoke(crate::lower::impl_self_ty_query)]
  43     #[salsa::cycle(crate::lower::impl_self_ty_recover)]
  44     fn impl_self_ty(&self, def: ImplId) -> Binders<Ty>;
  45
  46     #[salsa::invoke(crate::lower::const_param_ty_query)]
  47     fn const_param_ty(&self, def: ConstParamId) -> Ty;
  48
  49     #[salsa::invoke(crate::consteval::const_eval_variant_query)]
  50     #[salsa::cycle(crate::consteval::const_eval_recover)]
  51     fn const_eval(&self, def: ConstId) -> Result<ComputedExpr, ConstEvalError>;
  52
  53     #[salsa::invoke(crate::consteval::const_eval_query_variant)]
  54     #[salsa::cycle(crate::consteval::const_eval_variant_recover)]
  55     fn const_eval_variant(&self, def: EnumVariantId) -> Result<ComputedExpr, ConstEvalError>;
  56
  57     #[salsa::invoke(crate::lower::impl_trait_query)]
  58     fn impl_trait(&self, def: ImplId) -> Option<Binders<TraitRef>>;
  59
  60     #[salsa::invoke(crate::lower::field_types_query)]
  61     fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>>;
  62
  63     #[salsa::invoke(crate::layout::layout_of_adt_query)]
  64     #[salsa::cycle(crate::layout::layout_of_adt_recover)]
  65     fn layout_of_adt(&self, def: AdtId, subst: Substitution) -> Result<Layout, LayoutError>;
  66
  67     #[salsa::invoke(crate::layout::target_data_layout_query)]
  68     fn target_data_layout(&self, krate: CrateId) -> Arc<TargetDataLayout>;
  69
  70     #[salsa::invoke(crate::lower::callable_item_sig)]
  71     fn callable_item_signature(&self, def: CallableDefId) -> PolyFnSig;
  72
  73     #[salsa::invoke(crate::lower::return_type_impl_traits)]
  74     fn return_type_impl_traits(
  75         &self,
  76         def: FunctionId,
  77     ) -> Option<Arc<Binders<ReturnTypeImplTraits>>>;
  78
  79     #[salsa::invoke(crate::lower::generic_predicates_for_param_query)]
  80     #[salsa::cycle(crate::lower::generic_predicates_for_param_recover)]
  81     fn generic_predicates_for_param(
  82         &self,
  83         def: GenericDefId,
  84         param_id: TypeOrConstParamId,
  85         assoc_name: Option<Name>,
  86     ) -> Arc<[Binders<QuantifiedWhereClause>]>;
  87
  88     #[salsa::invoke(crate::lower::generic_predicates_query)]
  89     fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<QuantifiedWhereClause>]>;
  90
  91     #[salsa::invoke(crate::lower::trait_environment_query)]
  92     fn trait_environment(&self, def: GenericDefId) -> Arc<crate::TraitEnvironment>;
  93
  94     #[salsa::invoke(crate::lower::generic_defaults_query)]
  95     #[salsa::cycle(crate::lower::generic_defaults_recover)]
  96     fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<GenericArg>]>;
  97
  98     #[salsa::invoke(InherentImpls::inherent_impls_in_crate_query)]
  99     fn inherent_impls_in_crate(&self, krate: CrateId) -> Arc<InherentImpls>;
 100
 101     #[salsa::invoke(InherentImpls::inherent_impls_in_block_query)]
 102     fn inherent_impls_in_block(&self, block: BlockId) -> Option<Arc<InherentImpls>>;
 103
 104     /// Collects all crates in the dependency graph that have impls for the
 105     /// given fingerprint. This is only used for primitive types and types
 106     /// annotated with `rustc_has_incoherent_inherent_impls`; for other types
 107     /// we just look at the crate where the type is defined.
 108     #[salsa::invoke(crate::method_resolution::incoherent_inherent_impl_crates)]
 109     fn incoherent_inherent_impl_crates(
 110         &self,
 111         krate: CrateId,
 112         fp: TyFingerprint,
 113     ) -> SmallVec<[CrateId; 2]>;
 114
 115     #[salsa::invoke(TraitImpls::trait_impls_in_crate_query)]
 116     fn trait_impls_in_crate(&self, krate: CrateId) -> Arc<TraitImpls>;
 117
 118     #[salsa::invoke(TraitImpls::trait_impls_in_block_query)]
 119     fn trait_impls_in_block(&self, krate: BlockId) -> Option<Arc<TraitImpls>>;
 120
 121     #[salsa::invoke(TraitImpls::trait_impls_in_deps_query)]
 122     fn trait_impls_in_deps(&self, krate: CrateId) -> Arc<TraitImpls>;
 123
 124     // Interned IDs for Chalk integration
 125     #[salsa::interned]
 126     fn intern_callable_def(&self, callable_def: CallableDefId) -> InternedCallableDefId;
 127     #[salsa::interned]
 128     fn intern_type_or_const_param_id(
 129         &self,
 130         param_id: TypeOrConstParamId,
 131     ) -> InternedTypeOrConstParamId;
 132     #[salsa::interned]
 133     fn intern_lifetime_param_id(&self, param_id: LifetimeParamId) -> InternedLifetimeParamId;
 134     #[salsa::interned]
 135     fn intern_impl_trait_id(&self, id: ImplTraitId) -> InternedOpaqueTyId;
 136     #[salsa::interned]
 137     fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId;
 138     #[salsa::interned]
 139     fn intern_generator(&self, id: (DefWithBodyId, ExprId)) -> InternedGeneratorId;
 140
 141     #[salsa::invoke(chalk_db::associated_ty_data_query)]
 142     fn associated_ty_data(&self, id: chalk_db::AssocTypeId) -> Arc<chalk_db::AssociatedTyDatum>;
 143
 144     #[salsa::invoke(chalk_db::trait_datum_query)]
 145     fn trait_datum(&self, krate: CrateId, trait_id: chalk_db::TraitId)
 146         -> Arc<chalk_db::TraitDatum>;
 147
 148     #[salsa::invoke(chalk_db::struct_datum_query)]
 149     fn struct_datum(
 150         &self,
 151         krate: CrateId,
 152         struct_id: chalk_db::AdtId,
 153     ) -> Arc<chalk_db::StructDatum>;
 154
 155     #[salsa::invoke(chalk_db::impl_datum_query)]
 156     fn impl_datum(&self, krate: CrateId, impl_id: chalk_db::ImplId) -> Arc<chalk_db::ImplDatum>;
 157
 158     #[salsa::invoke(chalk_db::fn_def_datum_query)]
 159     fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk_db::FnDefDatum>;
 160
 161     #[salsa::invoke(chalk_db::fn_def_variance_query)]
 162     fn fn_def_variance(&self, fn_def_id: FnDefId) -> chalk_db::Variances;
 163
 164     #[salsa::invoke(chalk_db::adt_variance_query)]
 165     fn adt_variance(&self, adt_id: chalk_db::AdtId) -> chalk_db::Variances;
 166
 167     #[salsa::invoke(chalk_db::associated_ty_value_query)]
 168     fn associated_ty_value(
 169         &self,
 170         krate: CrateId,
 171         id: chalk_db::AssociatedTyValueId,
 172     ) -> Arc<chalk_db::AssociatedTyValue>;
 173
 174     #[salsa::invoke(crate::traits::normalize_projection_query)]
 175     #[salsa::transparent]
 176     fn normalize_projection(
 177         &self,
 178         projection: crate::ProjectionTy,
 179         env: Arc<crate::TraitEnvironment>,
 180     ) -> Ty;
 181
 182     #[salsa::invoke(trait_solve_wait)]
 183     #[salsa::transparent]
 184     fn trait_solve(
 185         &self,
 186         krate: CrateId,
 187         goal: crate::Canonical<crate::InEnvironment<crate::Goal>>,
 188     ) -> Option<crate::Solution>;
 189
 190     #[salsa::invoke(crate::traits::trait_solve_query)]
 191     fn trait_solve_query(
 192         &self,
 193         krate: CrateId,
 194         goal: crate::Canonical<crate::InEnvironment<crate::Goal>>,
 195     ) -> Option<crate::Solution>;
 196
 197     #[salsa::invoke(chalk_db::program_clauses_for_chalk_env_query)]
 198     fn program_clauses_for_chalk_env(
 199         &self,
 200         krate: CrateId,
 201         env: chalk_ir::Environment<Interner>,
 202     ) -> chalk_ir::ProgramClauses<Interner>;
 203 }
 204
 205 fn infer_wait(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
 206     let _p = profile::span("infer:wait").detail(|| match def {
 207         DefWithBodyId::FunctionId(it) => db.function_data(it).name.to_string(),
 208         DefWithBodyId::StaticId(it) => db.static_data(it).name.clone().to_string(),
 209         DefWithBodyId::ConstId(it) => {
 210             db.const_data(it).name.clone().unwrap_or_else(Name::missing).to_string()
 211         }
 212         DefWithBodyId::VariantId(it) => {
 213             db.enum_data(it.parent).variants[it.local_id].name.to_string()
 214         }
 215     });
 216     db.infer_query(def)
 217 }
 218
 219 fn trait_solve_wait(
 220     db: &dyn HirDatabase,
 221     krate: CrateId,
 222     goal: crate::Canonical<crate::InEnvironment<crate::Goal>>,
 223 ) -> Option<crate::Solution> {
 224     let _p = profile::span("trait_solve::wait");
 225     db.trait_solve_query(krate, goal)
 226 }
 227
 228 #[test]
 229 fn hir_database_is_object_safe() {
 230     fn _assert_object_safe(_: &dyn HirDatabase) {}
 231 }
 232
 233 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 234 pub struct InternedTypeOrConstParamId(salsa::InternId);
 235 impl_intern_key!(InternedTypeOrConstParamId);
 236
 237 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 238 pub struct InternedLifetimeParamId(salsa::InternId);
 239 impl_intern_key!(InternedLifetimeParamId);
 240
 241 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 242 pub struct InternedConstParamId(salsa::InternId);
 243 impl_intern_key!(InternedConstParamId);
 244
 245 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 246 pub struct InternedOpaqueTyId(salsa::InternId);
 247 impl_intern_key!(InternedOpaqueTyId);
 248
 249 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 250 pub struct InternedClosureId(salsa::InternId);
 251 impl_intern_key!(InternedClosureId);
 252
 253 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 254 pub struct InternedGeneratorId(salsa::InternId);
 255 impl_intern_key!(InternedGeneratorId);
 256
 257 /// This exists just for Chalk, because Chalk just has a single `FnDefId` where
 258 /// we have different IDs for struct and enum variant constructors.
 259 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 260 pub struct InternedCallableDefId(salsa::InternId);
 261 impl_intern_key!(InternedCallableDefId);