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 pro_ty = TyBuilder::assoc_type_projection(db, type_alias)
 414         .fill_with_bound_vars(crate::DebruijnIndex::INNERMOST, 0)
 415         .build();
 416     let self_ty = TyKind::Alias(AliasTy::Projection(pro_ty)).intern(Interner);
 417     let mut bounds: Vec<_> = type_alias_data
 418         .bounds
 419         .iter()
 420         .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone(), false))
 421         .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
 422         .collect();
 423
 424     if !ctx.unsized_types.borrow().contains(&self_ty) {
 425         let sized_trait = db
 426             .lang_item(resolver.krate(), SmolStr::new_inline("sized"))
 427             .and_then(|lang_item| lang_item.as_trait().map(to_chalk_trait_id));
 428         let sized_bound = sized_trait.into_iter().map(|sized_trait| {
 429             let trait_bound =
 430                 rust_ir::TraitBound { trait_id: sized_trait, args_no_self: Default::default() };
 431             let inline_bound = rust_ir::InlineBound::TraitBound(trait_bound);
 432             chalk_ir::Binders::empty(Interner, inline_bound)
 433         });
 434         bounds.extend(sized_bound);
 435         bounds.shrink_to_fit();
 436     }
 437
 438     // FIXME: Re-enable where clauses on associated types when an upstream chalk bug is fixed.
 439     //        (rust-analyzer#9052)
 440     // let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
 441     let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses: vec![] };
 442     let datum = AssociatedTyDatum {
 443         trait_id: to_chalk_trait_id(trait_),
 444         id,
 445         name: type_alias,
 446         binders: make_binders(db, &generic_params, bound_data),
 447     };
 448     Arc::new(datum)
 449 }
 450
 451 pub(crate) fn trait_datum_query(
 452     db: &dyn HirDatabase,
 453     krate: CrateId,
 454     trait_id: TraitId,
 455 ) -> Arc<TraitDatum> {
 456     debug!("trait_datum {:?}", trait_id);
 457     let trait_ = from_chalk_trait_id(trait_id);
 458     let trait_data = db.trait_data(trait_);
 459     debug!("trait {:?} = {:?}", trait_id, trait_data.name);
 460     let generic_params = generics(db.upcast(), trait_.into());
 461     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 462     let flags = rust_ir::TraitFlags {
 463         auto: trait_data.is_auto,
 464         upstream: trait_.lookup(db.upcast()).container.krate() != krate,
 465         non_enumerable: true,
 466         coinductive: false, // only relevant for Chalk testing
 467         // FIXME: set these flags correctly
 468         marker: false,
 469         fundamental: false,
 470     };
 471     let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
 472     let associated_ty_ids = trait_data.associated_types().map(to_assoc_type_id).collect();
 473     let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses };
 474     let well_known =
 475         lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name));
 476     let trait_datum = TraitDatum {
 477         id: trait_id,
 478         binders: make_binders(db, &generic_params, trait_datum_bound),
 479         flags,
 480         associated_ty_ids,
 481         well_known,
 482     };
 483     Arc::new(trait_datum)
 484 }
 485
 486 fn well_known_trait_from_lang_attr(name: &str) -> Option<WellKnownTrait> {
 487     Some(match name {
 488         "clone" => WellKnownTrait::Clone,
 489         "coerce_unsized" => WellKnownTrait::CoerceUnsized,
 490         "copy" => WellKnownTrait::Copy,
 491         "discriminant_kind" => WellKnownTrait::DiscriminantKind,
 492         "dispatch_from_dyn" => WellKnownTrait::DispatchFromDyn,
 493         "drop" => WellKnownTrait::Drop,
 494         "fn" => WellKnownTrait::Fn,
 495         "fn_mut" => WellKnownTrait::FnMut,
 496         "fn_once" => WellKnownTrait::FnOnce,
 497         "generator" => WellKnownTrait::Generator,
 498         "sized" => WellKnownTrait::Sized,
 499         "unpin" => WellKnownTrait::Unpin,
 500         "unsize" => WellKnownTrait::Unsize,
 501         _ => return None,
 502     })
 503 }
 504
 505 fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str {
 506     match attr {
 507         WellKnownTrait::Clone => "clone",
 508         WellKnownTrait::CoerceUnsized => "coerce_unsized",
 509         WellKnownTrait::Copy => "copy",
 510         WellKnownTrait::DiscriminantKind => "discriminant_kind",
 511         WellKnownTrait::DispatchFromDyn => "dispatch_from_dyn",
 512         WellKnownTrait::Drop => "drop",
 513         WellKnownTrait::Fn => "fn",
 514         WellKnownTrait::FnMut => "fn_mut",
 515         WellKnownTrait::FnOnce => "fn_once",
 516         WellKnownTrait::Generator => "generator",
 517         WellKnownTrait::Sized => "sized",
 518         WellKnownTrait::Unpin => "unpin",
 519         WellKnownTrait::Unsize => "unsize",
 520     }
 521 }
 522
 523 pub(crate) fn struct_datum_query(
 524     db: &dyn HirDatabase,
 525     krate: CrateId,
 526     struct_id: AdtId,
 527 ) -> Arc<StructDatum> {
 528     debug!("struct_datum {:?}", struct_id);
 529     let chalk_ir::AdtId(adt_id) = struct_id;
 530     let generic_params = generics(db.upcast(), adt_id.into());
 531     let upstream = adt_id.module(db.upcast()).krate() != krate;
 532     let where_clauses = {
 533         let generic_params = generics(db.upcast(), adt_id.into());
 534         let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 535         convert_where_clauses(db, adt_id.into(), &bound_vars)
 536     };
 537     let flags = rust_ir::AdtFlags {
 538         upstream,
 539         // FIXME set fundamental and phantom_data flags correctly
 540         fundamental: false,
 541         phantom_data: false,
 542     };
 543     // FIXME provide enum variants properly (for auto traits)
 544     let variant = rust_ir::AdtVariantDatum {
 545         fields: Vec::new(), // FIXME add fields (only relevant for auto traits),
 546     };
 547     let struct_datum_bound = rust_ir::AdtDatumBound { variants: vec![variant], where_clauses };
 548     let struct_datum = StructDatum {
 549         // FIXME set ADT kind
 550         kind: rust_ir::AdtKind::Struct,
 551         id: struct_id,
 552         binders: make_binders(db, &generic_params, struct_datum_bound),
 553         flags,
 554     };
 555     Arc::new(struct_datum)
 556 }
 557
 558 pub(crate) fn impl_datum_query(
 559     db: &dyn HirDatabase,
 560     krate: CrateId,
 561     impl_id: ImplId,
 562 ) -> Arc<ImplDatum> {
 563     let _p = profile::span("impl_datum");
 564     debug!("impl_datum {:?}", impl_id);
 565     let impl_: hir_def::ImplId = from_chalk(db, impl_id);
 566     impl_def_datum(db, krate, impl_id, impl_)
 567 }
 568
 569 fn impl_def_datum(
 570     db: &dyn HirDatabase,
 571     krate: CrateId,
 572     chalk_id: ImplId,
 573     impl_id: hir_def::ImplId,
 574 ) -> Arc<ImplDatum> {
 575     let trait_ref = db
 576         .impl_trait(impl_id)
 577         // ImplIds for impls where the trait ref can't be resolved should never reach Chalk
 578         .expect("invalid impl passed to Chalk")
 579         .into_value_and_skipped_binders()
 580         .0;
 581     let impl_data = db.impl_data(impl_id);
 582
 583     let generic_params = generics(db.upcast(), impl_id.into());
 584     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 585     let trait_ = trait_ref.hir_trait_id();
 586     let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
 587         rust_ir::ImplType::Local
 588     } else {
 589         rust_ir::ImplType::External
 590     };
 591     let where_clauses = convert_where_clauses(db, impl_id.into(), &bound_vars);
 592     let negative = impl_data.is_negative;
 593     debug!(
 594         "impl {:?}: {}{} where {:?}",
 595         chalk_id,
 596         if negative { "!" } else { "" },
 597         trait_ref.display(db),
 598         where_clauses
 599     );
 600
 601     let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
 602
 603     let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses };
 604     let trait_data = db.trait_data(trait_);
 605     let associated_ty_value_ids = impl_data
 606         .items
 607         .iter()
 608         .filter_map(|item| match item {
 609             AssocItemId::TypeAliasId(type_alias) => Some(*type_alias),
 610             _ => None,
 611         })
 612         .filter(|&type_alias| {
 613             // don't include associated types that don't exist in the trait
 614             let name = &db.type_alias_data(type_alias).name;
 615             trait_data.associated_type_by_name(name).is_some()
 616         })
 617         .map(|type_alias| TypeAliasAsValue(type_alias).to_chalk(db))
 618         .collect();
 619     debug!("impl_datum: {:?}", impl_datum_bound);
 620     let impl_datum = ImplDatum {
 621         binders: make_binders(db, &generic_params, impl_datum_bound),
 622         impl_type,
 623         polarity,
 624         associated_ty_value_ids,
 625     };
 626     Arc::new(impl_datum)
 627 }
 628
 629 pub(crate) fn associated_ty_value_query(
 630     db: &dyn HirDatabase,
 631     krate: CrateId,
 632     id: AssociatedTyValueId,
 633 ) -> Arc<AssociatedTyValue> {
 634     let type_alias: TypeAliasAsValue = from_chalk(db, id);
 635     type_alias_associated_ty_value(db, krate, type_alias.0)
 636 }
 637
 638 fn type_alias_associated_ty_value(
 639     db: &dyn HirDatabase,
 640     _krate: CrateId,
 641     type_alias: TypeAliasId,
 642 ) -> Arc<AssociatedTyValue> {
 643     let type_alias_data = db.type_alias_data(type_alias);
 644     let impl_id = match type_alias.lookup(db.upcast()).container {
 645         ItemContainerId::ImplId(it) => it,
 646         _ => panic!("assoc ty value should be in impl"),
 647     };
 648
 649     let trait_ref = db
 650         .impl_trait(impl_id)
 651         .expect("assoc ty value should not exist")
 652         .into_value_and_skipped_binders()
 653         .0; // we don't return any assoc ty values if the impl'd trait can't be resolved
 654
 655     let assoc_ty = db
 656         .trait_data(trait_ref.hir_trait_id())
 657         .associated_type_by_name(&type_alias_data.name)
 658         .expect("assoc ty value should not exist"); // validated when building the impl data as well
 659     let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders();
 660     let value_bound = rust_ir::AssociatedTyValueBound { ty };
 661     let value = rust_ir::AssociatedTyValue {
 662         impl_id: impl_id.to_chalk(db),
 663         associated_ty_id: to_assoc_type_id(assoc_ty),
 664         value: chalk_ir::Binders::new(binders, value_bound),
 665     };
 666     Arc::new(value)
 667 }
 668
 669 pub(crate) fn fn_def_datum_query(
 670     db: &dyn HirDatabase,
 671     _krate: CrateId,
 672     fn_def_id: FnDefId,
 673 ) -> Arc<FnDefDatum> {
 674     let callable_def: CallableDefId = from_chalk(db, fn_def_id);
 675     let generic_params = generics(db.upcast(), callable_def.into());
 676     let (sig, binders) = db.callable_item_signature(callable_def).into_value_and_skipped_binders();
 677     let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
 678     let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
 679     let bound = rust_ir::FnDefDatumBound {
 680         // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
 681         inputs_and_output: chalk_ir::Binders::empty(
 682             Interner,
 683             rust_ir::FnDefInputsAndOutputDatum {
 684                 argument_types: sig.params().to_vec(),
 685                 return_type: sig.ret().clone(),
 686             }
 687             .shifted_in(Interner),
 688         ),
 689         where_clauses,
 690     };
 691     let datum = FnDefDatum {
 692         id: fn_def_id,
 693         sig: chalk_ir::FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: sig.is_varargs },
 694         binders: chalk_ir::Binders::new(binders, bound),
 695     };
 696     Arc::new(datum)
 697 }
 698
 699 pub(crate) fn fn_def_variance_query(db: &dyn HirDatabase, fn_def_id: FnDefId) -> Variances {
 700     let callable_def: CallableDefId = from_chalk(db, fn_def_id);
 701     let generic_params = generics(db.upcast(), callable_def.into());
 702     Variances::from_iter(
 703         Interner,
 704         std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()),
 705     )
 706 }
 707
 708 pub(crate) fn adt_variance_query(
 709     db: &dyn HirDatabase,
 710     chalk_ir::AdtId(adt_id): AdtId,
 711 ) -> Variances {
 712     let generic_params = generics(db.upcast(), adt_id.into());
 713     Variances::from_iter(
 714         Interner,
 715         std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()),
 716     )
 717 }
 718
 719 pub(super) fn convert_where_clauses(
 720     db: &dyn HirDatabase,
 721     def: GenericDefId,
 722     substs: &Substitution,
 723 ) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
 724     let generic_predicates = db.generic_predicates(def);
 725     let mut result = Vec::with_capacity(generic_predicates.len());
 726     for pred in generic_predicates.iter() {
 727         result.push(pred.clone().substitute(Interner, substs));
 728     }
 729     result
 730 }
 731
 732 pub(super) fn generic_predicate_to_inline_bound(
 733     db: &dyn HirDatabase,
 734     pred: &QuantifiedWhereClause,
 735     self_ty: &Ty,
 736 ) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
 737     // An InlineBound is like a GenericPredicate, except the self type is left out.
 738     // We don't have a special type for this, but Chalk does.
 739     let self_ty_shifted_in = self_ty.clone().shifted_in_from(Interner, DebruijnIndex::ONE);
 740     let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
 741     match pred {
 742         WhereClause::Implemented(trait_ref) => {
 743             if trait_ref.self_type_parameter(Interner) != self_ty_shifted_in {
 744                 // we can only convert predicates back to type bounds if they
 745                 // have the expected self type
 746                 return None;
 747             }
 748             let args_no_self = trait_ref.substitution.as_slice(Interner)[1..]
 749                 .iter()
 750                 .map(|ty| ty.clone().cast(Interner))
 751                 .collect();
 752             let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
 753             Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
 754         }
 755         WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
 756             if projection_ty.self_type_parameter(Interner) != self_ty_shifted_in {
 757                 return None;
 758             }
 759             let trait_ = projection_ty.trait_(db);
 760             let args_no_self = projection_ty.substitution.as_slice(Interner)[1..]
 761                 .iter()
 762                 .map(|ty| ty.clone().cast(Interner))
 763                 .collect();
 764             let alias_eq_bound = rust_ir::AliasEqBound {
 765                 value: ty.clone(),
 766                 trait_bound: rust_ir::TraitBound {
 767                     trait_id: to_chalk_trait_id(trait_),
 768                     args_no_self,
 769                 },
 770                 associated_ty_id: projection_ty.associated_ty_id,
 771                 parameters: Vec::new(), // FIXME we don't support generic associated types yet
 772             };
 773             Some(chalk_ir::Binders::new(
 774                 binders,
 775                 rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
 776             ))
 777         }
 778         _ => None,
 779     }
 780 }