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 proj_bound = WhereClause::AliasEq(AliasEq {
 245                         alias: AliasTy::Projection(ProjectionTy {
 246                             associated_ty_id: to_assoc_type_id(future_output),
 247                             // Self type as the first parameter.
 248                             substitution: Substitution::from1(
 249                                 Interner,
 250                                 TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
 251                                     .intern(Interner),
 252                             ),
 253                         }),
 254                         // The parameter of the opaque type.
 255                         ty: TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 })
 256                             .intern(Interner),
 257                     });
 258                     let bound = OpaqueTyDatumBound {
 259                         bounds: make_single_type_binders(vec![
 260                             crate::wrap_empty_binders(impl_bound),
 261                             crate::wrap_empty_binders(proj_bound),
 262                         ]),
 263                         where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
 264                     };
 265                     // The opaque type has 1 parameter.
 266                     make_single_type_binders(bound)
 267                 } else {
 268                     // If failed to find Symbol’s value as variable is void: Future::Output, return empty bounds as fallback.
 269                     let bound = OpaqueTyDatumBound {
 270                         bounds: chalk_ir::Binders::empty(Interner, vec![]),
 271                         where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
 272                     };
 273                     // The opaque type has 1 parameter.
 274                     make_single_type_binders(bound)
 275                 }
 276             }
 277         };
 278
 279         Arc::new(OpaqueTyDatum { opaque_ty_id: id, bound })
 280     }
 281
 282     fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> {
 283         // FIXME: actually provide the hidden type; it is relevant for auto traits
 284         TyKind::Error.intern(Interner)
 285     }
 286
 287     fn is_object_safe(&self, _trait_id: chalk_ir::TraitId<Interner>) -> bool {
 288         // FIXME: implement actual object safety
 289         true
 290     }
 291
 292     fn closure_kind(
 293         &self,
 294         _closure_id: chalk_ir::ClosureId<Interner>,
 295         _substs: &chalk_ir::Substitution<Interner>,
 296     ) -> rust_ir::ClosureKind {
 297         // Fn is the closure kind that implements all three traits
 298         rust_ir::ClosureKind::Fn
 299     }
 300     fn closure_inputs_and_output(
 301         &self,
 302         _closure_id: chalk_ir::ClosureId<Interner>,
 303         substs: &chalk_ir::Substitution<Interner>,
 304     ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> {
 305         let sig_ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone();
 306         let sig = &sig_ty.callable_sig(self.db).expect("first closure param should be fn ptr");
 307         let io = rust_ir::FnDefInputsAndOutputDatum {
 308             argument_types: sig.params().to_vec(),
 309             return_type: sig.ret().clone(),
 310         };
 311         chalk_ir::Binders::empty(Interner, io.shifted_in(Interner))
 312     }
 313     fn closure_upvars(
 314         &self,
 315         _closure_id: chalk_ir::ClosureId<Interner>,
 316         _substs: &chalk_ir::Substitution<Interner>,
 317     ) -> chalk_ir::Binders<chalk_ir::Ty<Interner>> {
 318         let ty = TyBuilder::unit();
 319         chalk_ir::Binders::empty(Interner, ty)
 320     }
 321     fn closure_fn_substitution(
 322         &self,
 323         _closure_id: chalk_ir::ClosureId<Interner>,
 324         _substs: &chalk_ir::Substitution<Interner>,
 325     ) -> chalk_ir::Substitution<Interner> {
 326         Substitution::empty(Interner)
 327     }
 328
 329     fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
 330         let id = from_chalk_trait_id(trait_id);
 331         self.db.trait_data(id).name.to_string()
 332     }
 333     fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String {
 334         match adt_id {
 335             hir_def::AdtId::StructId(id) => self.db.struct_data(id).name.to_string(),
 336             hir_def::AdtId::EnumId(id) => self.db.enum_data(id).name.to_string(),
 337             hir_def::AdtId::UnionId(id) => self.db.union_data(id).name.to_string(),
 338         }
 339     }
 340     fn adt_size_align(&self, _id: chalk_ir::AdtId<Interner>) -> Arc<rust_ir::AdtSizeAlign> {
 341         // FIXME
 342         Arc::new(rust_ir::AdtSizeAlign::from_one_zst(false))
 343     }
 344     fn assoc_type_name(&self, assoc_ty_id: chalk_ir::AssocTypeId<Interner>) -> String {
 345         let id = self.db.associated_ty_data(assoc_ty_id).name;
 346         self.db.type_alias_data(id).name.to_string()
 347     }
 348     fn opaque_type_name(&self, opaque_ty_id: chalk_ir::OpaqueTyId<Interner>) -> String {
 349         format!("Opaque_{}", opaque_ty_id.0)
 350     }
 351     fn fn_def_name(&self, fn_def_id: chalk_ir::FnDefId<Interner>) -> String {
 352         format!("fn_{}", fn_def_id.0)
 353     }
 354     fn generator_datum(
 355         &self,
 356         _: chalk_ir::GeneratorId<Interner>,
 357     ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorDatum<Interner>> {
 358         // FIXME
 359         unimplemented!()
 360     }
 361     fn generator_witness_datum(
 362         &self,
 363         _: chalk_ir::GeneratorId<Interner>,
 364     ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorWitnessDatum<Interner>> {
 365         // FIXME
 366         unimplemented!()
 367     }
 368
 369     fn unification_database(&self) -> &dyn chalk_ir::UnificationDatabase<Interner> {
 370         &self.db
 371     }
 372 }
 373
 374 impl<'a> chalk_ir::UnificationDatabase<Interner> for &'a dyn HirDatabase {
 375     fn fn_def_variance(
 376         &self,
 377         fn_def_id: chalk_ir::FnDefId<Interner>,
 378     ) -> chalk_ir::Variances<Interner> {
 379         HirDatabase::fn_def_variance(*self, fn_def_id)
 380     }
 381
 382     fn adt_variance(&self, adt_id: chalk_ir::AdtId<Interner>) -> chalk_ir::Variances<Interner> {
 383         HirDatabase::adt_variance(*self, adt_id)
 384     }
 385 }
 386
 387 pub(crate) fn program_clauses_for_chalk_env_query(
 388     db: &dyn HirDatabase,
 389     krate: CrateId,
 390     environment: chalk_ir::Environment<Interner>,
 391 ) -> chalk_ir::ProgramClauses<Interner> {
 392     chalk_solve::program_clauses_for_env(&ChalkContext { db, krate }, &environment)
 393 }
 394
 395 pub(crate) fn associated_ty_data_query(
 396     db: &dyn HirDatabase,
 397     id: AssocTypeId,
 398 ) -> Arc<AssociatedTyDatum> {
 399     debug!("associated_ty_data {:?}", id);
 400     let type_alias: TypeAliasId = from_assoc_type_id(id);
 401     let trait_ = match type_alias.lookup(db.upcast()).container {
 402         ItemContainerId::TraitId(t) => t,
 403         _ => panic!("associated type not in trait"),
 404     };
 405
 406     // Lower bounds -- we could/should maybe move this to a separate query in `lower`
 407     let type_alias_data = db.type_alias_data(type_alias);
 408     let generic_params = generics(db.upcast(), type_alias.into());
 409     // let bound_vars = generic_params.bound_vars_subst(DebruijnIndex::INNERMOST);
 410     let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
 411     let ctx = crate::TyLoweringContext::new(db, &resolver)
 412         .with_type_param_mode(crate::lower::ParamLoweringMode::Variable);
 413     let self_ty =
 414         TyKind::BoundVar(BoundVar::new(crate::DebruijnIndex::INNERMOST, 0)).intern(Interner);
 415     let mut bounds: Vec<_> = type_alias_data
 416         .bounds
 417         .iter()
 418         .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone(), false))
 419         .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
 420         .collect();
 421
 422     if !ctx.unsized_types.borrow().contains(&self_ty) {
 423         let sized_trait = db
 424             .lang_item(resolver.krate(), SmolStr::new_inline("sized"))
 425             .and_then(|lang_item| lang_item.as_trait().map(to_chalk_trait_id));
 426         let sized_bound = sized_trait.into_iter().map(|sized_trait| {
 427             let trait_bound =
 428                 rust_ir::TraitBound { trait_id: sized_trait, args_no_self: Default::default() };
 429             let inline_bound = rust_ir::InlineBound::TraitBound(trait_bound);
 430             chalk_ir::Binders::empty(Interner, inline_bound)
 431         });
 432         bounds.extend(sized_bound);
 433         bounds.shrink_to_fit();
 434     }
 435
 436     // FIXME: Re-enable where clauses on associated types when an upstream chalk bug is fixed.
 437     //        (rust-analyzer#9052)
 438     // let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
 439     let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses: vec![] };
 440     let datum = AssociatedTyDatum {
 441         trait_id: to_chalk_trait_id(trait_),
 442         id,
 443         name: type_alias,
 444         binders: make_binders(db, &generic_params, bound_data),
 445     };
 446     Arc::new(datum)
 447 }
 448
 449 pub(crate) fn trait_datum_query(
 450     db: &dyn HirDatabase,
 451     krate: CrateId,
 452     trait_id: TraitId,
 453 ) -> Arc<TraitDatum> {
 454     debug!("trait_datum {:?}", trait_id);
 455     let trait_ = from_chalk_trait_id(trait_id);
 456     let trait_data = db.trait_data(trait_);
 457     debug!("trait {:?} = {:?}", trait_id, trait_data.name);
 458     let generic_params = generics(db.upcast(), trait_.into());
 459     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 460     let flags = rust_ir::TraitFlags {
 461         auto: trait_data.is_auto,
 462         upstream: trait_.lookup(db.upcast()).container.krate() != krate,
 463         non_enumerable: true,
 464         coinductive: false, // only relevant for Chalk testing
 465         // FIXME: set these flags correctly
 466         marker: false,
 467         fundamental: false,
 468     };
 469     let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
 470     let associated_ty_ids = trait_data.associated_types().map(to_assoc_type_id).collect();
 471     let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses };
 472     let well_known =
 473         lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name));
 474     let trait_datum = TraitDatum {
 475         id: trait_id,
 476         binders: make_binders(db, &generic_params, trait_datum_bound),
 477         flags,
 478         associated_ty_ids,
 479         well_known,
 480     };
 481     Arc::new(trait_datum)
 482 }
 483
 484 fn well_known_trait_from_lang_attr(name: &str) -> Option<WellKnownTrait> {
 485     Some(match name {
 486         "clone" => WellKnownTrait::Clone,
 487         "coerce_unsized" => WellKnownTrait::CoerceUnsized,
 488         "copy" => WellKnownTrait::Copy,
 489         "discriminant_kind" => WellKnownTrait::DiscriminantKind,
 490         "dispatch_from_dyn" => WellKnownTrait::DispatchFromDyn,
 491         "drop" => WellKnownTrait::Drop,
 492         "fn" => WellKnownTrait::Fn,
 493         "fn_mut" => WellKnownTrait::FnMut,
 494         "fn_once" => WellKnownTrait::FnOnce,
 495         "generator" => WellKnownTrait::Generator,
 496         "sized" => WellKnownTrait::Sized,
 497         "unpin" => WellKnownTrait::Unpin,
 498         "unsize" => WellKnownTrait::Unsize,
 499         _ => return None,
 500     })
 501 }
 502
 503 fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str {
 504     match attr {
 505         WellKnownTrait::Clone => "clone",
 506         WellKnownTrait::CoerceUnsized => "coerce_unsized",
 507         WellKnownTrait::Copy => "copy",
 508         WellKnownTrait::DiscriminantKind => "discriminant_kind",
 509         WellKnownTrait::DispatchFromDyn => "dispatch_from_dyn",
 510         WellKnownTrait::Drop => "drop",
 511         WellKnownTrait::Fn => "fn",
 512         WellKnownTrait::FnMut => "fn_mut",
 513         WellKnownTrait::FnOnce => "fn_once",
 514         WellKnownTrait::Generator => "generator",
 515         WellKnownTrait::Sized => "sized",
 516         WellKnownTrait::Unpin => "unpin",
 517         WellKnownTrait::Unsize => "unsize",
 518     }
 519 }
 520
 521 pub(crate) fn struct_datum_query(
 522     db: &dyn HirDatabase,
 523     krate: CrateId,
 524     struct_id: AdtId,
 525 ) -> Arc<StructDatum> {
 526     debug!("struct_datum {:?}", struct_id);
 527     let chalk_ir::AdtId(adt_id) = struct_id;
 528     let generic_params = generics(db.upcast(), adt_id.into());
 529     let upstream = adt_id.module(db.upcast()).krate() != krate;
 530     let where_clauses = {
 531         let generic_params = generics(db.upcast(), adt_id.into());
 532         let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 533         convert_where_clauses(db, adt_id.into(), &bound_vars)
 534     };
 535     let flags = rust_ir::AdtFlags {
 536         upstream,
 537         // FIXME set fundamental and phantom_data flags correctly
 538         fundamental: false,
 539         phantom_data: false,
 540     };
 541     // FIXME provide enum variants properly (for auto traits)
 542     let variant = rust_ir::AdtVariantDatum {
 543         fields: Vec::new(), // FIXME add fields (only relevant for auto traits),
 544     };
 545     let struct_datum_bound = rust_ir::AdtDatumBound { variants: vec![variant], where_clauses };
 546     let struct_datum = StructDatum {
 547         // FIXME set ADT kind
 548         kind: rust_ir::AdtKind::Struct,
 549         id: struct_id,
 550         binders: make_binders(db, &generic_params, struct_datum_bound),
 551         flags,
 552     };
 553     Arc::new(struct_datum)
 554 }
 555
 556 pub(crate) fn impl_datum_query(
 557     db: &dyn HirDatabase,
 558     krate: CrateId,
 559     impl_id: ImplId,
 560 ) -> Arc<ImplDatum> {
 561     let _p = profile::span("impl_datum");
 562     debug!("impl_datum {:?}", impl_id);
 563     let impl_: hir_def::ImplId = from_chalk(db, impl_id);
 564     impl_def_datum(db, krate, impl_id, impl_)
 565 }
 566
 567 fn impl_def_datum(
 568     db: &dyn HirDatabase,
 569     krate: CrateId,
 570     chalk_id: ImplId,
 571     impl_id: hir_def::ImplId,
 572 ) -> Arc<ImplDatum> {
 573     let trait_ref = db
 574         .impl_trait(impl_id)
 575         // ImplIds for impls where the trait ref can't be resolved should never reach Chalk
 576         .expect("invalid impl passed to Chalk")
 577         .into_value_and_skipped_binders()
 578         .0;
 579     let impl_data = db.impl_data(impl_id);
 580
 581     let generic_params = generics(db.upcast(), impl_id.into());
 582     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 583     let trait_ = trait_ref.hir_trait_id();
 584     let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
 585         rust_ir::ImplType::Local
 586     } else {
 587         rust_ir::ImplType::External
 588     };
 589     let where_clauses = convert_where_clauses(db, impl_id.into(), &bound_vars);
 590     let negative = impl_data.is_negative;
 591     debug!(
 592         "impl {:?}: {}{} where {:?}",
 593         chalk_id,
 594         if negative { "!" } else { "" },
 595         trait_ref.display(db),
 596         where_clauses
 597     );
 598
 599     let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
 600
 601     let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses };
 602     let trait_data = db.trait_data(trait_);
 603     let associated_ty_value_ids = impl_data
 604         .items
 605         .iter()
 606         .filter_map(|item| match item {
 607             AssocItemId::TypeAliasId(type_alias) => Some(*type_alias),
 608             _ => None,
 609         })
 610         .filter(|&type_alias| {
 611             // don't include associated types that don't exist in the trait
 612             let name = &db.type_alias_data(type_alias).name;
 613             trait_data.associated_type_by_name(name).is_some()
 614         })
 615         .map(|type_alias| TypeAliasAsValue(type_alias).to_chalk(db))
 616         .collect();
 617     debug!("impl_datum: {:?}", impl_datum_bound);
 618     let impl_datum = ImplDatum {
 619         binders: make_binders(db, &generic_params, impl_datum_bound),
 620         impl_type,
 621         polarity,
 622         associated_ty_value_ids,
 623     };
 624     Arc::new(impl_datum)
 625 }
 626
 627 pub(crate) fn associated_ty_value_query(
 628     db: &dyn HirDatabase,
 629     krate: CrateId,
 630     id: AssociatedTyValueId,
 631 ) -> Arc<AssociatedTyValue> {
 632     let type_alias: TypeAliasAsValue = from_chalk(db, id);
 633     type_alias_associated_ty_value(db, krate, type_alias.0)
 634 }
 635
 636 fn type_alias_associated_ty_value(
 637     db: &dyn HirDatabase,
 638     _krate: CrateId,
 639     type_alias: TypeAliasId,
 640 ) -> Arc<AssociatedTyValue> {
 641     let type_alias_data = db.type_alias_data(type_alias);
 642     let impl_id = match type_alias.lookup(db.upcast()).container {
 643         ItemContainerId::ImplId(it) => it,
 644         _ => panic!("assoc ty value should be in impl"),
 645     };
 646
 647     let trait_ref = db
 648         .impl_trait(impl_id)
 649         .expect("assoc ty value should not exist")
 650         .into_value_and_skipped_binders()
 651         .0; // we don't return any assoc ty values if the impl'd trait can't be resolved
 652
 653     let assoc_ty = db
 654         .trait_data(trait_ref.hir_trait_id())
 655         .associated_type_by_name(&type_alias_data.name)
 656         .expect("assoc ty value should not exist"); // validated when building the impl data as well
 657     let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders();
 658     let value_bound = rust_ir::AssociatedTyValueBound { ty };
 659     let value = rust_ir::AssociatedTyValue {
 660         impl_id: impl_id.to_chalk(db),
 661         associated_ty_id: to_assoc_type_id(assoc_ty),
 662         value: chalk_ir::Binders::new(binders, value_bound),
 663     };
 664     Arc::new(value)
 665 }
 666
 667 pub(crate) fn fn_def_datum_query(
 668     db: &dyn HirDatabase,
 669     _krate: CrateId,
 670     fn_def_id: FnDefId,
 671 ) -> Arc<FnDefDatum> {
 672     let callable_def: CallableDefId = from_chalk(db, fn_def_id);
 673     let generic_params = generics(db.upcast(), callable_def.into());
 674     let (sig, binders) = db.callable_item_signature(callable_def).into_value_and_skipped_binders();
 675     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 676     let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
 677     let bound = rust_ir::FnDefDatumBound {
 678         // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
 679         inputs_and_output: chalk_ir::Binders::empty(
 680             Interner,
 681             rust_ir::FnDefInputsAndOutputDatum {
 682                 argument_types: sig.params().to_vec(),
 683                 return_type: sig.ret().clone(),
 684             }
 685             .shifted_in(Interner),
 686         ),
 687         where_clauses,
 688     };
 689     let datum = FnDefDatum {
 690         id: fn_def_id,
 691         sig: chalk_ir::FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: sig.is_varargs },
 692         binders: chalk_ir::Binders::new(binders, bound),
 693     };
 694     Arc::new(datum)
 695 }
 696
 697 pub(crate) fn fn_def_variance_query(db: &dyn HirDatabase, fn_def_id: FnDefId) -> Variances {
 698     let callable_def: CallableDefId = from_chalk(db, fn_def_id);
 699     let generic_params = generics(db.upcast(), callable_def.into());
 700     Variances::from_iter(
 701         Interner,
 702         std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()),
 703     )
 704 }
 705
 706 pub(crate) fn adt_variance_query(
 707     db: &dyn HirDatabase,
 708     chalk_ir::AdtId(adt_id): AdtId,
 709 ) -> Variances {
 710     let generic_params = generics(db.upcast(), adt_id.into());
 711     Variances::from_iter(
 712         Interner,
 713         std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()),
 714     )
 715 }
 716
 717 pub(super) fn convert_where_clauses(
 718     db: &dyn HirDatabase,
 719     def: GenericDefId,
 720     substs: &Substitution,
 721 ) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
 722     let generic_predicates = db.generic_predicates(def);
 723     let mut result = Vec::with_capacity(generic_predicates.len());
 724     for pred in generic_predicates.iter() {
 725         result.push(pred.clone().substitute(Interner, substs));
 726     }
 727     result
 728 }
 729
 730 pub(super) fn generic_predicate_to_inline_bound(
 731     db: &dyn HirDatabase,
 732     pred: &QuantifiedWhereClause,
 733     self_ty: &Ty,
 734 ) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
 735     // An InlineBound is like a GenericPredicate, except the self type is left out.
 736     // We don't have a special type for this, but Chalk does.
 737     let self_ty_shifted_in = self_ty.clone().shifted_in_from(Interner, DebruijnIndex::ONE);
 738     let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
 739     match pred {
 740         WhereClause::Implemented(trait_ref) => {
 741             if trait_ref.self_type_parameter(Interner) != self_ty_shifted_in {
 742                 // we can only convert predicates back to type bounds if they
 743                 // have the expected self type
 744                 return None;
 745             }
 746             let args_no_self = trait_ref.substitution.as_slice(Interner)[1..]
 747                 .iter()
 748                 .map(|ty| ty.clone().cast(Interner))
 749                 .collect();
 750             let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
 751             Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
 752         }
 753         WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
 754             if projection_ty.self_type_parameter(Interner) != self_ty_shifted_in {
 755                 return None;
 756             }
 757             let trait_ = projection_ty.trait_(db);
 758             let args_no_self = projection_ty.substitution.as_slice(Interner)[1..]
 759                 .iter()
 760                 .map(|ty| ty.clone().cast(Interner))
 761                 .collect();
 762             let alias_eq_bound = rust_ir::AliasEqBound {
 763                 value: ty.clone(),
 764                 trait_bound: rust_ir::TraitBound {
 765                     trait_id: to_chalk_trait_id(trait_),
 766                     args_no_self,
 767                 },
 768                 associated_ty_id: projection_ty.associated_ty_id,
 769                 parameters: Vec::new(), // FIXME we don't support generic associated types yet
 770             };
 771             Some(chalk_ir::Binders::new(
 772                 binders,
 773                 rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
 774             ))
 775         }
 776         _ => None,
 777     }
 778 }