crates/hir-ty/src/chalk_db.rs

   1 //! The implementation of `RustIrDatabase` for Chalk, which provides information
   2 //! about the code that Chalk needs.
   3 use std::sync::Arc;
   4
   5 use cov_mark::hit;
   6 use syntax::SmolStr;
   7 use tracing::debug;
   8
   9 use chalk_ir::{cast::Cast, fold::shift::Shift, CanonicalVarKinds};
  10 use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
  11
  12 use base_db::CrateId;
  13 use hir_def::{
  14     lang_item::{lang_attr, LangItemTarget},
  15     AssocItemId, GenericDefId, HasModule, ItemContainerId, Lookup, ModuleId, TypeAliasId,
  16 };
  17 use hir_expand::name::name;
  18
  19 use crate::{
  20     db::HirDatabase,
  21     display::HirDisplay,
  22     from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, make_binders,
  23     make_single_type_binders,
  24     mapping::{from_chalk, ToChalk, TypeAliasAsValue},
  25     method_resolution::{TraitImpls, TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
  26     to_assoc_type_id, to_chalk_trait_id,
  27     traits::ChalkContext,
  28     utils::generics,
  29     AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, Interner, ProjectionTy,
  30     ProjectionTyExt, QuantifiedWhereClause, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder,
  31     TyExt, TyKind, WhereClause,
  32 };
  33
  34 pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
  35 pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
  36 pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
  37 pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
  38 pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
  39
  40 pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
  41 pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
  42 pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
  43 pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
  44 pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
  45 pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
  46 pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
  47 pub(crate) type Variances = chalk_ir::Variances<Interner>;
  48
  49 impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
  50     fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
  51         self.db.associated_ty_data(id)
  52     }
  53     fn trait_datum(&self, trait_id: TraitId) -> Arc<TraitDatum> {
  54         self.db.trait_datum(self.krate, trait_id)
  55     }
  56     fn adt_datum(&self, struct_id: AdtId) -> Arc<StructDatum> {
  57         self.db.struct_datum(self.krate, struct_id)
  58     }
  59     fn adt_repr(&self, _struct_id: AdtId) -> Arc<rust_ir::AdtRepr<Interner>> {
  60         // FIXME: keep track of these
  61         Arc::new(rust_ir::AdtRepr { c: false, packed: false, int: None })
  62     }
  63     fn discriminant_type(&self, _ty: chalk_ir::Ty<Interner>) -> chalk_ir::Ty<Interner> {
  64         // FIXME: keep track of this
  65         chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::U32)).intern(Interner)
  66     }
  67     fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum> {
  68         self.db.impl_datum(self.krate, impl_id)
  69     }
  70
  71     fn fn_def_datum(
  72         &self,
  73         fn_def_id: chalk_ir::FnDefId<Interner>,
  74     ) -> Arc<rust_ir::FnDefDatum<Interner>> {
  75         self.db.fn_def_datum(self.krate, fn_def_id)
  76     }
  77
  78     fn impls_for_trait(
  79         &self,
  80         trait_id: TraitId,
  81         parameters: &[chalk_ir::GenericArg<Interner>],
  82         binders: &CanonicalVarKinds<Interner>,
  83     ) -> Vec<ImplId> {
  84         debug!("impls_for_trait {:?}", trait_id);
  85         let trait_: hir_def::TraitId = from_chalk_trait_id(trait_id);
  86
  87         let ty: Ty = parameters[0].assert_ty_ref(Interner).clone();
  88
  89         fn binder_kind(
  90             ty: &Ty,
  91             binders: &CanonicalVarKinds<Interner>,
  92         ) -> Option<chalk_ir::TyVariableKind> {
  93             if let TyKind::BoundVar(bv) = ty.kind(Interner) {
  94                 let binders = binders.as_slice(Interner);
  95                 if bv.debruijn == DebruijnIndex::INNERMOST {
  96                     if let chalk_ir::VariableKind::Ty(tk) = binders[bv.index].kind {
  97                         return Some(tk);
  98                     }
  99                 }
 100             }
 101             None
 102         }
 103
 104         let self_ty_fp = TyFingerprint::for_trait_impl(&ty);
 105         let fps: &[TyFingerprint] = match binder_kind(&ty, binders) {
 106             Some(chalk_ir::TyVariableKind::Integer) => &ALL_INT_FPS,
 107             Some(chalk_ir::TyVariableKind::Float) => &ALL_FLOAT_FPS,
 108             _ => self_ty_fp.as_ref().map(std::slice::from_ref).unwrap_or(&[]),
 109         };
 110
 111         fn local_impls(db: &dyn HirDatabase, module: ModuleId) -> Option<Arc<TraitImpls>> {
 112             let block = module.containing_block()?;
 113             hit!(block_local_impls);
 114             db.trait_impls_in_block(block)
 115         }
 116
 117         // Note: Since we're using impls_for_trait, only impls where the trait
 118         // can be resolved should ever reach Chalk. impl_datum relies on that
 119         // and will panic if the trait can't be resolved.
 120         let in_deps = self.db.trait_impls_in_deps(self.krate);
 121         let in_self = self.db.trait_impls_in_crate(self.krate);
 122         let trait_module = trait_.module(self.db.upcast());
 123         let type_module = match self_ty_fp {
 124             Some(TyFingerprint::Adt(adt_id)) => Some(adt_id.module(self.db.upcast())),
 125             Some(TyFingerprint::ForeignType(type_id)) => {
 126                 Some(from_foreign_def_id(type_id).module(self.db.upcast()))
 127             }
 128             Some(TyFingerprint::Dyn(trait_id)) => Some(trait_id.module(self.db.upcast())),
 129             _ => None,
 130         };
 131         let impl_maps = [
 132             Some(in_deps),
 133             Some(in_self),
 134             local_impls(self.db, trait_module),
 135             type_module.and_then(|m| local_impls(self.db, m)),
 136         ];
 137
 138         let id_to_chalk = |id: hir_def::ImplId| id.to_chalk(self.db);
 139
 140         let result: Vec<_> = if fps.is_empty() {
 141             debug!("Unrestricted search for {:?} impls...", trait_);
 142             impl_maps
 143                 .iter()
 144                 .filter_map(|o| o.as_ref())
 145                 .flat_map(|impls| impls.for_trait(trait_).map(id_to_chalk))
 146                 .collect()
 147         } else {
 148             impl_maps
 149                 .iter()
 150                 .filter_map(|o| o.as_ref())
 151                 .flat_map(|impls| {
 152                     fps.iter().flat_map(move |fp| {
 153                         impls.for_trait_and_self_ty(trait_, *fp).map(id_to_chalk)
 154                     })
 155                 })
 156                 .collect()
 157         };
 158
 159         debug!("impls_for_trait returned {} impls", result.len());
 160         result
 161     }
 162     fn impl_provided_for(&self, auto_trait_id: TraitId, kind: &chalk_ir::TyKind<Interner>) -> bool {
 163         debug!("impl_provided_for {:?}, {:?}", auto_trait_id, kind);
 164         false // FIXME
 165     }
 166     fn associated_ty_value(&self, id: AssociatedTyValueId) -> Arc<AssociatedTyValue> {
 167         self.db.associated_ty_value(self.krate, id)
 168     }
 169
 170     fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<Interner>> {
 171         vec![]
 172     }
 173     fn local_impls_to_coherence_check(&self, _trait_id: TraitId) -> Vec<ImplId> {
 174         // We don't do coherence checking (yet)
 175         unimplemented!()
 176     }
 177     fn interner(&self) -> Interner {
 178         Interner
 179     }
 180     fn well_known_trait_id(
 181         &self,
 182         well_known_trait: rust_ir::WellKnownTrait,
 183     ) -> Option<chalk_ir::TraitId<Interner>> {
 184         let lang_attr = lang_attr_from_well_known_trait(well_known_trait);
 185         let trait_ = match self.db.lang_item(self.krate, lang_attr.into()) {
 186             Some(LangItemTarget::TraitId(trait_)) => trait_,
 187             _ => return None,
 188         };
 189         Some(to_chalk_trait_id(trait_))
 190     }
 191
 192     fn program_clauses_for_env(
 193         &self,
 194         environment: &chalk_ir::Environment<Interner>,
 195     ) -> chalk_ir::ProgramClauses<Interner> {
 196         self.db.program_clauses_for_chalk_env(self.krate, environment.clone())
 197     }
 198
 199     fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatum> {
 200         let full_id = self.db.lookup_intern_impl_trait_id(id.into());
 201         let bound = match full_id {
 202             crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
 203                 let datas = self
 204                     .db
 205                     .return_type_impl_traits(func)
 206                     .expect("impl trait id without impl traits");
 207                 let (datas, binders) = (*datas).as_ref().into_value_and_skipped_binders();
 208                 let data = &datas.impl_traits[idx as usize];
 209                 let bound = OpaqueTyDatumBound {
 210                     bounds: make_single_type_binders(data.bounds.skip_binders().to_vec()),
 211                     where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
 212                 };
 213                 chalk_ir::Binders::new(binders, bound)
 214             }
 215             crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => {
 216                 if let Some((future_trait, future_output)) = self
 217                     .db
 218                     .lang_item(self.krate, SmolStr::new_inline("future_trait"))
 219                     .and_then(|item| item.as_trait())
 220                     .and_then(|trait_| {
 221                         let alias =
 222                             self.db.trait_data(trait_).associated_type_by_name(&name![Output])?;
 223                         Some((trait_, alias))
 224                     })
 225                 {
 226                     // Making up Symbol’s value as variable is void: AsyncBlock<T>:
 227                     //
 228                     // |--------------------OpaqueTyDatum-------------------|
 229                     //        |-------------OpaqueTyDatumBound--------------|
 230                     // for<T> <Self> [Future<Self>, Future::Output<Self> = T]
 231                     //     ^1  ^0            ^0                    ^0      ^1
 232                     let impl_bound = WhereClause::Implemented(TraitRef {
 233                         trait_id: to_chalk_trait_id(future_trait),
 234                         // Self type as the first parameter.
 235                         substitution: Substitution::from1(
 236                             Interner,
 237                             TyKind::BoundVar(BoundVar {
 238                                 debruijn: DebruijnIndex::INNERMOST,
 239                                 index: 0,
 240                             })
 241                             .intern(Interner),
 242                         ),
 243                     });
 244                     let mut binder = vec![];
 245                     binder.push(crate::wrap_empty_binders(impl_bound));
 246                     let sized_trait = self
 247                         .db
 248                         .lang_item(self.krate, SmolStr::new_inline("sized"))
 249                         .and_then(|item| item.as_trait());
 250                     if let Some(sized_trait_) = sized_trait {
 251                         let sized_bound = WhereClause::Implemented(TraitRef {
 252                             trait_id: to_chalk_trait_id(sized_trait_),
 253                             // Self type as the first parameter.
 254                             substitution: Substitution::from1(
 255                                 Interner,
 256                                 TyKind::BoundVar(BoundVar {
 257                                     debruijn: DebruijnIndex::INNERMOST,
 258                                     index: 0,
 259                                 })
 260                                 .intern(Interner),
 261                             ),
 262                         });
 263                         binder.push(crate::wrap_empty_binders(sized_bound));
 264                     }
 265                     let proj_bound = WhereClause::AliasEq(AliasEq {
 266                         alias: AliasTy::Projection(ProjectionTy {
 267                             associated_ty_id: to_assoc_type_id(future_output),
 268                             // Self type as the first parameter.
 269                             substitution: Substitution::from1(
 270                                 Interner,
 271                                 TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
 272                                     .intern(Interner),
 273                             ),
 274                         }),
 275                         // The parameter of the opaque type.
 276                         ty: TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 })
 277                             .intern(Interner),
 278                     });
 279                     binder.push(crate::wrap_empty_binders(proj_bound));
 280                     let bound = OpaqueTyDatumBound {
 281                         bounds: make_single_type_binders(binder),
 282                         where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
 283                     };
 284                     // The opaque type has 1 parameter.
 285                     make_single_type_binders(bound)
 286                 } else {
 287                     // If failed to find Symbol’s value as variable is void: Future::Output, return empty bounds as fallback.
 288                     let bound = OpaqueTyDatumBound {
 289                         bounds: chalk_ir::Binders::empty(Interner, vec![]),
 290                         where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
 291                     };
 292                     // The opaque type has 1 parameter.
 293                     make_single_type_binders(bound)
 294                 }
 295             }
 296         };
 297
 298         Arc::new(OpaqueTyDatum { opaque_ty_id: id, bound })
 299     }
 300
 301     fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> {
 302         // FIXME: actually provide the hidden type; it is relevant for auto traits
 303         TyKind::Error.intern(Interner)
 304     }
 305
 306     fn is_object_safe(&self, _trait_id: chalk_ir::TraitId<Interner>) -> bool {
 307         // FIXME: implement actual object safety
 308         true
 309     }
 310
 311     fn closure_kind(
 312         &self,
 313         _closure_id: chalk_ir::ClosureId<Interner>,
 314         _substs: &chalk_ir::Substitution<Interner>,
 315     ) -> rust_ir::ClosureKind {
 316         // Fn is the closure kind that implements all three traits
 317         rust_ir::ClosureKind::Fn
 318     }
 319     fn closure_inputs_and_output(
 320         &self,
 321         _closure_id: chalk_ir::ClosureId<Interner>,
 322         substs: &chalk_ir::Substitution<Interner>,
 323     ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> {
 324         let sig_ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone();
 325         let sig = &sig_ty.callable_sig(self.db).expect("first closure param should be fn ptr");
 326         let io = rust_ir::FnDefInputsAndOutputDatum {
 327             argument_types: sig.params().to_vec(),
 328             return_type: sig.ret().clone(),
 329         };
 330         chalk_ir::Binders::empty(Interner, io.shifted_in(Interner))
 331     }
 332     fn closure_upvars(
 333         &self,
 334         _closure_id: chalk_ir::ClosureId<Interner>,
 335         _substs: &chalk_ir::Substitution<Interner>,
 336     ) -> chalk_ir::Binders<chalk_ir::Ty<Interner>> {
 337         let ty = TyBuilder::unit();
 338         chalk_ir::Binders::empty(Interner, ty)
 339     }
 340     fn closure_fn_substitution(
 341         &self,
 342         _closure_id: chalk_ir::ClosureId<Interner>,
 343         _substs: &chalk_ir::Substitution<Interner>,
 344     ) -> chalk_ir::Substitution<Interner> {
 345         Substitution::empty(Interner)
 346     }
 347
 348     fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
 349         let id = from_chalk_trait_id(trait_id);
 350         self.db.trait_data(id).name.to_string()
 351     }
 352     fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String {
 353         match adt_id {
 354             hir_def::AdtId::StructId(id) => self.db.struct_data(id).name.to_string(),
 355             hir_def::AdtId::EnumId(id) => self.db.enum_data(id).name.to_string(),
 356             hir_def::AdtId::UnionId(id) => self.db.union_data(id).name.to_string(),
 357         }
 358     }
 359     fn adt_size_align(&self, _id: chalk_ir::AdtId<Interner>) -> Arc<rust_ir::AdtSizeAlign> {
 360         // FIXME
 361         Arc::new(rust_ir::AdtSizeAlign::from_one_zst(false))
 362     }
 363     fn assoc_type_name(&self, assoc_ty_id: chalk_ir::AssocTypeId<Interner>) -> String {
 364         let id = self.db.associated_ty_data(assoc_ty_id).name;
 365         self.db.type_alias_data(id).name.to_string()
 366     }
 367     fn opaque_type_name(&self, opaque_ty_id: chalk_ir::OpaqueTyId<Interner>) -> String {
 368         format!("Opaque_{}", opaque_ty_id.0)
 369     }
 370     fn fn_def_name(&self, fn_def_id: chalk_ir::FnDefId<Interner>) -> String {
 371         format!("fn_{}", fn_def_id.0)
 372     }
 373     fn generator_datum(
 374         &self,
 375         _: chalk_ir::GeneratorId<Interner>,
 376     ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorDatum<Interner>> {
 377         // FIXME
 378         unimplemented!()
 379     }
 380     fn generator_witness_datum(
 381         &self,
 382         _: chalk_ir::GeneratorId<Interner>,
 383     ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorWitnessDatum<Interner>> {
 384         // FIXME
 385         unimplemented!()
 386     }
 387
 388     fn unification_database(&self) -> &dyn chalk_ir::UnificationDatabase<Interner> {
 389         &self.db
 390     }
 391 }
 392
 393 impl<'a> chalk_ir::UnificationDatabase<Interner> for &'a dyn HirDatabase {
 394     fn fn_def_variance(
 395         &self,
 396         fn_def_id: chalk_ir::FnDefId<Interner>,
 397     ) -> chalk_ir::Variances<Interner> {
 398         HirDatabase::fn_def_variance(*self, fn_def_id)
 399     }
 400
 401     fn adt_variance(&self, adt_id: chalk_ir::AdtId<Interner>) -> chalk_ir::Variances<Interner> {
 402         HirDatabase::adt_variance(*self, adt_id)
 403     }
 404 }
 405
 406 pub(crate) fn program_clauses_for_chalk_env_query(
 407     db: &dyn HirDatabase,
 408     krate: CrateId,
 409     environment: chalk_ir::Environment<Interner>,
 410 ) -> chalk_ir::ProgramClauses<Interner> {
 411     chalk_solve::program_clauses_for_env(&ChalkContext { db, krate }, &environment)
 412 }
 413
 414 pub(crate) fn associated_ty_data_query(
 415     db: &dyn HirDatabase,
 416     id: AssocTypeId,
 417 ) -> Arc<AssociatedTyDatum> {
 418     debug!("associated_ty_data {:?}", id);
 419     let type_alias: TypeAliasId = from_assoc_type_id(id);
 420     let trait_ = match type_alias.lookup(db.upcast()).container {
 421         ItemContainerId::TraitId(t) => t,
 422         _ => panic!("associated type not in trait"),
 423     };
 424
 425     // Lower bounds -- we could/should maybe move this to a separate query in `lower`
 426     let type_alias_data = db.type_alias_data(type_alias);
 427     let generic_params = generics(db.upcast(), type_alias.into());
 428     // let bound_vars = generic_params.bound_vars_subst(DebruijnIndex::INNERMOST);
 429     let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
 430     let ctx = crate::TyLoweringContext::new(db, &resolver)
 431         .with_type_param_mode(crate::lower::ParamLoweringMode::Variable);
 432     let pro_ty = TyBuilder::assoc_type_projection(db, type_alias)
 433         .fill_with_bound_vars(crate::DebruijnIndex::INNERMOST, 0)
 434         .build();
 435     let self_ty = TyKind::Alias(AliasTy::Projection(pro_ty)).intern(Interner);
 436     let mut bounds: Vec<_> = type_alias_data
 437         .bounds
 438         .iter()
 439         .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone(), false))
 440         .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
 441         .collect();
 442
 443     if !ctx.unsized_types.borrow().contains(&self_ty) {
 444         let sized_trait = db
 445             .lang_item(resolver.krate(), SmolStr::new_inline("sized"))
 446             .and_then(|lang_item| lang_item.as_trait().map(to_chalk_trait_id));
 447         let sized_bound = sized_trait.into_iter().map(|sized_trait| {
 448             let trait_bound =
 449                 rust_ir::TraitBound { trait_id: sized_trait, args_no_self: Default::default() };
 450             let inline_bound = rust_ir::InlineBound::TraitBound(trait_bound);
 451             chalk_ir::Binders::empty(Interner, inline_bound)
 452         });
 453         bounds.extend(sized_bound);
 454         bounds.shrink_to_fit();
 455     }
 456
 457     // FIXME: Re-enable where clauses on associated types when an upstream chalk bug is fixed.
 458     //        (rust-analyzer#9052)
 459     // let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
 460     let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses: vec![] };
 461     let datum = AssociatedTyDatum {
 462         trait_id: to_chalk_trait_id(trait_),
 463         id,
 464         name: type_alias,
 465         binders: make_binders(db, &generic_params, bound_data),
 466     };
 467     Arc::new(datum)
 468 }
 469
 470 pub(crate) fn trait_datum_query(
 471     db: &dyn HirDatabase,
 472     krate: CrateId,
 473     trait_id: TraitId,
 474 ) -> Arc<TraitDatum> {
 475     debug!("trait_datum {:?}", trait_id);
 476     let trait_ = from_chalk_trait_id(trait_id);
 477     let trait_data = db.trait_data(trait_);
 478     debug!("trait {:?} = {:?}", trait_id, trait_data.name);
 479     let generic_params = generics(db.upcast(), trait_.into());
 480     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 481     let flags = rust_ir::TraitFlags {
 482         auto: trait_data.is_auto,
 483         upstream: trait_.lookup(db.upcast()).container.krate() != krate,
 484         non_enumerable: true,
 485         coinductive: false, // only relevant for Chalk testing
 486         // FIXME: set these flags correctly
 487         marker: false,
 488         fundamental: false,
 489     };
 490     let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
 491     let associated_ty_ids = trait_data.associated_types().map(to_assoc_type_id).collect();
 492     let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses };
 493     let well_known =
 494         lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name));
 495     let trait_datum = TraitDatum {
 496         id: trait_id,
 497         binders: make_binders(db, &generic_params, trait_datum_bound),
 498         flags,
 499         associated_ty_ids,
 500         well_known,
 501     };
 502     Arc::new(trait_datum)
 503 }
 504
 505 fn well_known_trait_from_lang_attr(name: &str) -> Option<WellKnownTrait> {
 506     Some(match name {
 507         "clone" => WellKnownTrait::Clone,
 508         "coerce_unsized" => WellKnownTrait::CoerceUnsized,
 509         "copy" => WellKnownTrait::Copy,
 510         "discriminant_kind" => WellKnownTrait::DiscriminantKind,
 511         "dispatch_from_dyn" => WellKnownTrait::DispatchFromDyn,
 512         "drop" => WellKnownTrait::Drop,
 513         "fn" => WellKnownTrait::Fn,
 514         "fn_mut" => WellKnownTrait::FnMut,
 515         "fn_once" => WellKnownTrait::FnOnce,
 516         "generator" => WellKnownTrait::Generator,
 517         "sized" => WellKnownTrait::Sized,
 518         "unpin" => WellKnownTrait::Unpin,
 519         "unsize" => WellKnownTrait::Unsize,
 520         _ => return None,
 521     })
 522 }
 523
 524 fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str {
 525     match attr {
 526         WellKnownTrait::Clone => "clone",
 527         WellKnownTrait::CoerceUnsized => "coerce_unsized",
 528         WellKnownTrait::Copy => "copy",
 529         WellKnownTrait::DiscriminantKind => "discriminant_kind",
 530         WellKnownTrait::DispatchFromDyn => "dispatch_from_dyn",
 531         WellKnownTrait::Drop => "drop",
 532         WellKnownTrait::Fn => "fn",
 533         WellKnownTrait::FnMut => "fn_mut",
 534         WellKnownTrait::FnOnce => "fn_once",
 535         WellKnownTrait::Generator => "generator",
 536         WellKnownTrait::Sized => "sized",
 537         WellKnownTrait::Unpin => "unpin",
 538         WellKnownTrait::Unsize => "unsize",
 539     }
 540 }
 541
 542 pub(crate) fn struct_datum_query(
 543     db: &dyn HirDatabase,
 544     krate: CrateId,
 545     struct_id: AdtId,
 546 ) -> Arc<StructDatum> {
 547     debug!("struct_datum {:?}", struct_id);
 548     let chalk_ir::AdtId(adt_id) = struct_id;
 549     let generic_params = generics(db.upcast(), adt_id.into());
 550     let upstream = adt_id.module(db.upcast()).krate() != krate;
 551     let where_clauses = {
 552         let generic_params = generics(db.upcast(), adt_id.into());
 553         let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 554         convert_where_clauses(db, adt_id.into(), &bound_vars)
 555     };
 556     let flags = rust_ir::AdtFlags {
 557         upstream,
 558         // FIXME set fundamental and phantom_data flags correctly
 559         fundamental: false,
 560         phantom_data: false,
 561     };
 562     // FIXME provide enum variants properly (for auto traits)
 563     let variant = rust_ir::AdtVariantDatum {
 564         fields: Vec::new(), // FIXME add fields (only relevant for auto traits),
 565     };
 566     let struct_datum_bound = rust_ir::AdtDatumBound { variants: vec![variant], where_clauses };
 567     let struct_datum = StructDatum {
 568         // FIXME set ADT kind
 569         kind: rust_ir::AdtKind::Struct,
 570         id: struct_id,
 571         binders: make_binders(db, &generic_params, struct_datum_bound),
 572         flags,
 573     };
 574     Arc::new(struct_datum)
 575 }
 576
 577 pub(crate) fn impl_datum_query(
 578     db: &dyn HirDatabase,
 579     krate: CrateId,
 580     impl_id: ImplId,
 581 ) -> Arc<ImplDatum> {
 582     let _p = profile::span("impl_datum");
 583     debug!("impl_datum {:?}", impl_id);
 584     let impl_: hir_def::ImplId = from_chalk(db, impl_id);
 585     impl_def_datum(db, krate, impl_id, impl_)
 586 }
 587
 588 fn impl_def_datum(
 589     db: &dyn HirDatabase,
 590     krate: CrateId,
 591     chalk_id: ImplId,
 592     impl_id: hir_def::ImplId,
 593 ) -> Arc<ImplDatum> {
 594     let trait_ref = db
 595         .impl_trait(impl_id)
 596         // ImplIds for impls where the trait ref can't be resolved should never reach Chalk
 597         .expect("invalid impl passed to Chalk")
 598         .into_value_and_skipped_binders()
 599         .0;
 600     let impl_data = db.impl_data(impl_id);
 601
 602     let generic_params = generics(db.upcast(), impl_id.into());
 603     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 604     let trait_ = trait_ref.hir_trait_id();
 605     let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
 606         rust_ir::ImplType::Local
 607     } else {
 608         rust_ir::ImplType::External
 609     };
 610     let where_clauses = convert_where_clauses(db, impl_id.into(), &bound_vars);
 611     let negative = impl_data.is_negative;
 612     debug!(
 613         "impl {:?}: {}{} where {:?}",
 614         chalk_id,
 615         if negative { "!" } else { "" },
 616         trait_ref.display(db),
 617         where_clauses
 618     );
 619
 620     let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
 621
 622     let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses };
 623     let trait_data = db.trait_data(trait_);
 624     let associated_ty_value_ids = impl_data
 625         .items
 626         .iter()
 627         .filter_map(|item| match item {
 628             AssocItemId::TypeAliasId(type_alias) => Some(*type_alias),
 629             _ => None,
 630         })
 631         .filter(|&type_alias| {
 632             // don't include associated types that don't exist in the trait
 633             let name = &db.type_alias_data(type_alias).name;
 634             trait_data.associated_type_by_name(name).is_some()
 635         })
 636         .map(|type_alias| TypeAliasAsValue(type_alias).to_chalk(db))
 637         .collect();
 638     debug!("impl_datum: {:?}", impl_datum_bound);
 639     let impl_datum = ImplDatum {
 640         binders: make_binders(db, &generic_params, impl_datum_bound),
 641         impl_type,
 642         polarity,
 643         associated_ty_value_ids,
 644     };
 645     Arc::new(impl_datum)
 646 }
 647
 648 pub(crate) fn associated_ty_value_query(
 649     db: &dyn HirDatabase,
 650     krate: CrateId,
 651     id: AssociatedTyValueId,
 652 ) -> Arc<AssociatedTyValue> {
 653     let type_alias: TypeAliasAsValue = from_chalk(db, id);
 654     type_alias_associated_ty_value(db, krate, type_alias.0)
 655 }
 656
 657 fn type_alias_associated_ty_value(
 658     db: &dyn HirDatabase,
 659     _krate: CrateId,
 660     type_alias: TypeAliasId,
 661 ) -> Arc<AssociatedTyValue> {
 662     let type_alias_data = db.type_alias_data(type_alias);
 663     let impl_id = match type_alias.lookup(db.upcast()).container {
 664         ItemContainerId::ImplId(it) => it,
 665         _ => panic!("assoc ty value should be in impl"),
 666     };
 667
 668     let trait_ref = db
 669         .impl_trait(impl_id)
 670         .expect("assoc ty value should not exist")
 671         .into_value_and_skipped_binders()
 672         .0; // we don't return any assoc ty values if the impl'd trait can't be resolved
 673
 674     let assoc_ty = db
 675         .trait_data(trait_ref.hir_trait_id())
 676         .associated_type_by_name(&type_alias_data.name)
 677         .expect("assoc ty value should not exist"); // validated when building the impl data as well
 678     let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders();
 679     let value_bound = rust_ir::AssociatedTyValueBound { ty };
 680     let value = rust_ir::AssociatedTyValue {
 681         impl_id: impl_id.to_chalk(db),
 682         associated_ty_id: to_assoc_type_id(assoc_ty),
 683         value: chalk_ir::Binders::new(binders, value_bound),
 684     };
 685     Arc::new(value)
 686 }
 687
 688 pub(crate) fn fn_def_datum_query(
 689     db: &dyn HirDatabase,
 690     _krate: CrateId,
 691     fn_def_id: FnDefId,
 692 ) -> Arc<FnDefDatum> {
 693     let callable_def: CallableDefId = from_chalk(db, fn_def_id);
 694     let generic_params = generics(db.upcast(), callable_def.into());
 695     let (sig, binders) = db.callable_item_signature(callable_def).into_value_and_skipped_binders();
 696     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 697     let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
 698     let bound = rust_ir::FnDefDatumBound {
 699         // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
 700         inputs_and_output: chalk_ir::Binders::empty(
 701             Interner,
 702             rust_ir::FnDefInputsAndOutputDatum {
 703                 argument_types: sig.params().to_vec(),
 704                 return_type: sig.ret().clone(),
 705             }
 706             .shifted_in(Interner),
 707         ),
 708         where_clauses,
 709     };
 710     let datum = FnDefDatum {
 711         id: fn_def_id,
 712         sig: chalk_ir::FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: sig.is_varargs },
 713         binders: chalk_ir::Binders::new(binders, bound),
 714     };
 715     Arc::new(datum)
 716 }
 717
 718 pub(crate) fn fn_def_variance_query(db: &dyn HirDatabase, fn_def_id: FnDefId) -> Variances {
 719     let callable_def: CallableDefId = from_chalk(db, fn_def_id);
 720     let generic_params = generics(db.upcast(), callable_def.into());
 721     Variances::from_iter(
 722         Interner,
 723         std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()),
 724     )
 725 }
 726
 727 pub(crate) fn adt_variance_query(
 728     db: &dyn HirDatabase,
 729     chalk_ir::AdtId(adt_id): AdtId,
 730 ) -> Variances {
 731     let generic_params = generics(db.upcast(), adt_id.into());
 732     Variances::from_iter(
 733         Interner,
 734         std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()),
 735     )
 736 }
 737
 738 pub(super) fn convert_where_clauses(
 739     db: &dyn HirDatabase,
 740     def: GenericDefId,
 741     substs: &Substitution,
 742 ) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
 743     let generic_predicates = db.generic_predicates(def);
 744     let mut result = Vec::with_capacity(generic_predicates.len());
 745     for pred in generic_predicates.iter() {
 746         result.push(pred.clone().substitute(Interner, substs));
 747     }
 748     result
 749 }
 750
 751 pub(super) fn generic_predicate_to_inline_bound(
 752     db: &dyn HirDatabase,
 753     pred: &QuantifiedWhereClause,
 754     self_ty: &Ty,
 755 ) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
 756     // An InlineBound is like a GenericPredicate, except the self type is left out.
 757     // We don't have a special type for this, but Chalk does.
 758     let self_ty_shifted_in = self_ty.clone().shifted_in_from(Interner, DebruijnIndex::ONE);
 759     let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
 760     match pred {
 761         WhereClause::Implemented(trait_ref) => {
 762             if trait_ref.self_type_parameter(Interner) != self_ty_shifted_in {
 763                 // we can only convert predicates back to type bounds if they
 764                 // have the expected self type
 765                 return None;
 766             }
 767             let args_no_self = trait_ref.substitution.as_slice(Interner)[1..]
 768                 .iter()
 769                 .map(|ty| ty.clone().cast(Interner))
 770                 .collect();
 771             let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
 772             Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
 773         }
 774         WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
 775             if projection_ty.self_type_parameter(Interner) != self_ty_shifted_in {
 776                 return None;
 777             }
 778             let trait_ = projection_ty.trait_(db);
 779             let args_no_self = projection_ty.substitution.as_slice(Interner)[1..]
 780                 .iter()
 781                 .map(|ty| ty.clone().cast(Interner))
 782                 .collect();
 783             let alias_eq_bound = rust_ir::AliasEqBound {
 784                 value: ty.clone(),
 785                 trait_bound: rust_ir::TraitBound {
 786                     trait_id: to_chalk_trait_id(trait_),
 787                     args_no_self,
 788                 },
 789                 associated_ty_id: projection_ty.associated_ty_id,
 790                 parameters: Vec::new(), // FIXME we don't support generic associated types yet
 791             };
 792             Some(chalk_ir::Binders::new(
 793                 binders,
 794                 rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
 795             ))
 796         }
 797         _ => None,
 798     }
 799 }