1 //! The implementation of `RustIrDatabase` for Chalk, which provides information
2 //! about the code that Chalk needs.
9 use chalk_ir::{cast::Cast, fold::shift::Shift, CanonicalVarKinds};
10 use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
15 lang_item::{lang_attr, LangItemTarget},
16 AssocItemId, GenericDefId, HasModule, ItemContainerId, Lookup, ModuleId, TypeAliasId,
18 use hir_expand::name::name;
23 from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, make_binders,
24 make_single_type_binders,
25 mapping::{from_chalk, ToChalk, TypeAliasAsValue},
26 method_resolution::{TraitImpls, TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
27 to_assoc_type_id, to_chalk_trait_id,
30 wrap_empty_binders, AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId,
31 Interner, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause, Substitution, TraitRef,
32 TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
35 pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
36 pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
37 pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
38 pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
39 pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
41 pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
42 pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
43 pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
44 pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
45 pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
46 pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
47 pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
48 pub(crate) type Variances = chalk_ir::Variances<Interner>;
50 impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
51 fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
52 self.db.associated_ty_data(id)
54 fn trait_datum(&self, trait_id: TraitId) -> Arc<TraitDatum> {
55 self.db.trait_datum(self.krate, trait_id)
57 fn adt_datum(&self, struct_id: AdtId) -> Arc<StructDatum> {
58 self.db.struct_datum(self.krate, struct_id)
60 fn adt_repr(&self, _struct_id: AdtId) -> Arc<rust_ir::AdtRepr<Interner>> {
61 // FIXME: keep track of these
62 Arc::new(rust_ir::AdtRepr { c: false, packed: false, int: None })
64 fn discriminant_type(&self, _ty: chalk_ir::Ty<Interner>) -> chalk_ir::Ty<Interner> {
65 // FIXME: keep track of this
66 chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::U32)).intern(Interner)
68 fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum> {
69 self.db.impl_datum(self.krate, impl_id)
74 fn_def_id: chalk_ir::FnDefId<Interner>,
75 ) -> Arc<rust_ir::FnDefDatum<Interner>> {
76 self.db.fn_def_datum(self.krate, fn_def_id)
82 parameters: &[chalk_ir::GenericArg<Interner>],
83 binders: &CanonicalVarKinds<Interner>,
85 debug!("impls_for_trait {:?}", trait_id);
86 let trait_: hir_def::TraitId = from_chalk_trait_id(trait_id);
88 let ty: Ty = parameters[0].assert_ty_ref(Interner).clone();
92 binders: &CanonicalVarKinds<Interner>,
93 ) -> Option<chalk_ir::TyVariableKind> {
94 if let TyKind::BoundVar(bv) = ty.kind(Interner) {
95 let binders = binders.as_slice(Interner);
96 if bv.debruijn == DebruijnIndex::INNERMOST {
97 if let chalk_ir::VariableKind::Ty(tk) = binders[bv.index].kind {
105 let self_ty_fp = TyFingerprint::for_trait_impl(&ty);
106 let fps: &[TyFingerprint] = match binder_kind(&ty, binders) {
107 Some(chalk_ir::TyVariableKind::Integer) => &ALL_INT_FPS,
108 Some(chalk_ir::TyVariableKind::Float) => &ALL_FLOAT_FPS,
109 _ => self_ty_fp.as_ref().map(std::slice::from_ref).unwrap_or(&[]),
112 fn local_impls(db: &dyn HirDatabase, module: ModuleId) -> Option<Arc<TraitImpls>> {
113 let block = module.containing_block()?;
114 hit!(block_local_impls);
115 db.trait_impls_in_block(block)
118 // Note: Since we're using impls_for_trait, only impls where the trait
119 // can be resolved should ever reach Chalk. impl_datum relies on that
120 // and will panic if the trait can't be resolved.
121 let in_deps = self.db.trait_impls_in_deps(self.krate);
122 let in_self = self.db.trait_impls_in_crate(self.krate);
123 let trait_module = trait_.module(self.db.upcast());
124 let type_module = match self_ty_fp {
125 Some(TyFingerprint::Adt(adt_id)) => Some(adt_id.module(self.db.upcast())),
126 Some(TyFingerprint::ForeignType(type_id)) => {
127 Some(from_foreign_def_id(type_id).module(self.db.upcast()))
129 Some(TyFingerprint::Dyn(trait_id)) => Some(trait_id.module(self.db.upcast())),
135 local_impls(self.db, trait_module),
136 type_module.and_then(|m| local_impls(self.db, m)),
139 let id_to_chalk = |id: hir_def::ImplId| id.to_chalk(self.db);
141 let result: Vec<_> = if fps.is_empty() {
142 debug!("Unrestricted search for {:?} impls...", trait_);
145 .filter_map(|o| o.as_ref())
146 .flat_map(|impls| impls.for_trait(trait_).map(id_to_chalk))
151 .filter_map(|o| o.as_ref())
153 fps.iter().flat_map(move |fp| {
154 impls.for_trait_and_self_ty(trait_, *fp).map(id_to_chalk)
160 debug!("impls_for_trait returned {} impls", result.len());
163 fn impl_provided_for(&self, auto_trait_id: TraitId, kind: &chalk_ir::TyKind<Interner>) -> bool {
164 debug!("impl_provided_for {:?}, {:?}", auto_trait_id, kind);
167 fn associated_ty_value(&self, id: AssociatedTyValueId) -> Arc<AssociatedTyValue> {
168 self.db.associated_ty_value(self.krate, id)
171 fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<Interner>> {
174 fn local_impls_to_coherence_check(&self, _trait_id: TraitId) -> Vec<ImplId> {
175 // We don't do coherence checking (yet)
178 fn interner(&self) -> Interner {
181 fn well_known_trait_id(
183 well_known_trait: rust_ir::WellKnownTrait,
184 ) -> Option<chalk_ir::TraitId<Interner>> {
185 let lang_attr = lang_attr_from_well_known_trait(well_known_trait);
186 let trait_ = match self.db.lang_item(self.krate, lang_attr.into()) {
187 Some(LangItemTarget::TraitId(trait_)) => trait_,
190 Some(to_chalk_trait_id(trait_))
193 fn program_clauses_for_env(
195 environment: &chalk_ir::Environment<Interner>,
196 ) -> chalk_ir::ProgramClauses<Interner> {
197 self.db.program_clauses_for_chalk_env(self.krate, environment.clone())
200 fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatum> {
201 let full_id = self.db.lookup_intern_impl_trait_id(id.into());
202 let bound = match full_id {
203 crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
206 .return_type_impl_traits(func)
207 .expect("impl trait id without impl traits");
208 let (datas, binders) = (*datas).as_ref().into_value_and_skipped_binders();
209 let data = &datas.impl_traits[idx as usize];
210 let bound = OpaqueTyDatumBound {
211 bounds: make_single_type_binders(data.bounds.skip_binders().to_vec()),
212 where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
214 chalk_ir::Binders::new(binders, bound)
216 crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => {
217 if let Some((future_trait, future_output)) = self
219 .lang_item(self.krate, SmolStr::new_inline("future_trait"))
220 .and_then(|item| item.as_trait())
223 self.db.trait_data(trait_).associated_type_by_name(&name![Output])?;
224 Some((trait_, alias))
227 // Making up Symbol’s value as variable is void: AsyncBlock<T>:
229 // |--------------------OpaqueTyDatum-------------------|
230 // |-------------OpaqueTyDatumBound--------------|
231 // for<T> <Self> [Future<Self>, Future::Output<Self> = T]
233 let impl_bound = WhereClause::Implemented(TraitRef {
234 trait_id: to_chalk_trait_id(future_trait),
235 // Self type as the first parameter.
236 substitution: Substitution::from1(
238 TyKind::BoundVar(BoundVar {
239 debruijn: DebruijnIndex::INNERMOST,
245 let mut binder = vec![];
246 binder.push(crate::wrap_empty_binders(impl_bound));
247 let sized_trait = self
249 .lang_item(self.krate, SmolStr::new_inline("sized"))
250 .and_then(|item| item.as_trait());
251 if let Some(sized_trait_) = sized_trait {
252 let sized_bound = WhereClause::Implemented(TraitRef {
253 trait_id: to_chalk_trait_id(sized_trait_),
254 // Self type as the first parameter.
255 substitution: Substitution::from1(
257 TyKind::BoundVar(BoundVar {
258 debruijn: DebruijnIndex::INNERMOST,
264 binder.push(crate::wrap_empty_binders(sized_bound));
266 let proj_bound = WhereClause::AliasEq(AliasEq {
267 alias: AliasTy::Projection(ProjectionTy {
268 associated_ty_id: to_assoc_type_id(future_output),
269 // Self type as the first parameter.
270 substitution: Substitution::from1(
272 TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
276 // The parameter of the opaque type.
277 ty: TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 })
280 binder.push(crate::wrap_empty_binders(proj_bound));
281 let bound = OpaqueTyDatumBound {
282 bounds: make_single_type_binders(binder),
283 where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
285 // The opaque type has 1 parameter.
286 make_single_type_binders(bound)
288 // If failed to find Symbol’s value as variable is void: Future::Output, return empty bounds as fallback.
289 let bound = OpaqueTyDatumBound {
290 bounds: chalk_ir::Binders::empty(Interner, vec![]),
291 where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
293 // The opaque type has 1 parameter.
294 make_single_type_binders(bound)
299 Arc::new(OpaqueTyDatum { opaque_ty_id: id, bound })
302 fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> {
303 // FIXME: actually provide the hidden type; it is relevant for auto traits
304 TyKind::Error.intern(Interner)
307 fn is_object_safe(&self, _trait_id: chalk_ir::TraitId<Interner>) -> bool {
308 // FIXME: implement actual object safety
314 _closure_id: chalk_ir::ClosureId<Interner>,
315 _substs: &chalk_ir::Substitution<Interner>,
316 ) -> rust_ir::ClosureKind {
317 // Fn is the closure kind that implements all three traits
318 rust_ir::ClosureKind::Fn
320 fn closure_inputs_and_output(
322 _closure_id: chalk_ir::ClosureId<Interner>,
323 substs: &chalk_ir::Substitution<Interner>,
324 ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> {
325 let sig_ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone();
326 let sig = &sig_ty.callable_sig(self.db).expect("first closure param should be fn ptr");
327 let io = rust_ir::FnDefInputsAndOutputDatum {
328 argument_types: sig.params().to_vec(),
329 return_type: sig.ret().clone(),
331 chalk_ir::Binders::empty(Interner, io.shifted_in(Interner))
335 _closure_id: chalk_ir::ClosureId<Interner>,
336 _substs: &chalk_ir::Substitution<Interner>,
337 ) -> chalk_ir::Binders<chalk_ir::Ty<Interner>> {
338 let ty = TyBuilder::unit();
339 chalk_ir::Binders::empty(Interner, ty)
341 fn closure_fn_substitution(
343 _closure_id: chalk_ir::ClosureId<Interner>,
344 _substs: &chalk_ir::Substitution<Interner>,
345 ) -> chalk_ir::Substitution<Interner> {
346 Substitution::empty(Interner)
349 fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
350 let id = from_chalk_trait_id(trait_id);
351 self.db.trait_data(id).name.to_string()
353 fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String {
355 hir_def::AdtId::StructId(id) => self.db.struct_data(id).name.to_string(),
356 hir_def::AdtId::EnumId(id) => self.db.enum_data(id).name.to_string(),
357 hir_def::AdtId::UnionId(id) => self.db.union_data(id).name.to_string(),
360 fn adt_size_align(&self, _id: chalk_ir::AdtId<Interner>) -> Arc<rust_ir::AdtSizeAlign> {
362 Arc::new(rust_ir::AdtSizeAlign::from_one_zst(false))
364 fn assoc_type_name(&self, assoc_ty_id: chalk_ir::AssocTypeId<Interner>) -> String {
365 let id = self.db.associated_ty_data(assoc_ty_id).name;
366 self.db.type_alias_data(id).name.to_string()
368 fn opaque_type_name(&self, opaque_ty_id: chalk_ir::OpaqueTyId<Interner>) -> String {
369 format!("Opaque_{}", opaque_ty_id.0)
371 fn fn_def_name(&self, fn_def_id: chalk_ir::FnDefId<Interner>) -> String {
372 format!("fn_{}", fn_def_id.0)
376 id: chalk_ir::GeneratorId<Interner>,
377 ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorDatum<Interner>> {
378 let (parent, expr) = self.db.lookup_intern_generator(id.into());
380 // We fill substitution with unknown type, because we only need to know whether the generic
381 // params are types or consts to build `Binders` and those being filled up are for
382 // `resume_type`, `yield_type`, and `return_type` of the generator in question.
383 let subst = TyBuilder::subst_for_generator(self.db, parent).fill_with_unknown().build();
385 let input_output = rust_ir::GeneratorInputOutputDatum {
386 resume_type: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
388 yield_type: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 1))
390 return_type: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 2))
392 // FIXME: calculate upvars
398 .map(|it| it.constant(Interner).map(|c| c.data(Interner).ty.clone()));
399 let input_output = crate::make_type_and_const_binders(it, input_output);
401 let movability = match self.db.body(parent)[expr] {
402 hir_def::expr::Expr::Closure {
403 closure_kind: hir_def::expr::ClosureKind::Generator(movability),
406 _ => unreachable!("non generator expression interned as generator"),
408 let movability = match movability {
409 Movability::Static => rust_ir::Movability::Static,
410 Movability::Movable => rust_ir::Movability::Movable,
413 Arc::new(rust_ir::GeneratorDatum { movability, input_output })
415 fn generator_witness_datum(
417 id: chalk_ir::GeneratorId<Interner>,
418 ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorWitnessDatum<Interner>> {
419 // FIXME: calculate inner types
421 rust_ir::GeneratorWitnessExistential { types: wrap_empty_binders(vec![]) };
423 let (parent, _) = self.db.lookup_intern_generator(id.into());
424 // See the comment in `generator_datum()` for unknown types.
425 let subst = TyBuilder::subst_for_generator(self.db, parent).fill_with_unknown().build();
428 .map(|it| it.constant(Interner).map(|c| c.data(Interner).ty.clone()));
429 let inner_types = crate::make_type_and_const_binders(it, inner_types);
431 Arc::new(rust_ir::GeneratorWitnessDatum { inner_types })
434 fn unification_database(&self) -> &dyn chalk_ir::UnificationDatabase<Interner> {
439 impl<'a> chalk_ir::UnificationDatabase<Interner> for &'a dyn HirDatabase {
442 fn_def_id: chalk_ir::FnDefId<Interner>,
443 ) -> chalk_ir::Variances<Interner> {
444 HirDatabase::fn_def_variance(*self, fn_def_id)
447 fn adt_variance(&self, adt_id: chalk_ir::AdtId<Interner>) -> chalk_ir::Variances<Interner> {
448 HirDatabase::adt_variance(*self, adt_id)
452 pub(crate) fn program_clauses_for_chalk_env_query(
453 db: &dyn HirDatabase,
455 environment: chalk_ir::Environment<Interner>,
456 ) -> chalk_ir::ProgramClauses<Interner> {
457 chalk_solve::program_clauses_for_env(&ChalkContext { db, krate }, &environment)
460 pub(crate) fn associated_ty_data_query(
461 db: &dyn HirDatabase,
463 ) -> Arc<AssociatedTyDatum> {
464 debug!("associated_ty_data {:?}", id);
465 let type_alias: TypeAliasId = from_assoc_type_id(id);
466 let trait_ = match type_alias.lookup(db.upcast()).container {
467 ItemContainerId::TraitId(t) => t,
468 _ => panic!("associated type not in trait"),
471 // Lower bounds -- we could/should maybe move this to a separate query in `lower`
472 let type_alias_data = db.type_alias_data(type_alias);
473 let generic_params = generics(db.upcast(), type_alias.into());
474 // let bound_vars = generic_params.bound_vars_subst(DebruijnIndex::INNERMOST);
475 let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
476 let ctx = crate::TyLoweringContext::new(db, &resolver)
477 .with_type_param_mode(crate::lower::ParamLoweringMode::Variable);
479 let trait_subst = TyBuilder::subst_for_def(db, trait_, None)
480 .fill_with_bound_vars(crate::DebruijnIndex::INNERMOST, generic_params.len_self())
482 let pro_ty = TyBuilder::assoc_type_projection(db, type_alias, Some(trait_subst))
483 .fill_with_bound_vars(crate::DebruijnIndex::INNERMOST, 0)
485 let self_ty = TyKind::Alias(AliasTy::Projection(pro_ty)).intern(Interner);
487 let mut bounds: Vec<_> = type_alias_data
490 .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone(), false))
491 .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
494 if !ctx.unsized_types.borrow().contains(&self_ty) {
496 .lang_item(resolver.krate(), SmolStr::new_inline("sized"))
497 .and_then(|lang_item| lang_item.as_trait().map(to_chalk_trait_id));
498 let sized_bound = sized_trait.into_iter().map(|sized_trait| {
500 rust_ir::TraitBound { trait_id: sized_trait, args_no_self: Default::default() };
501 let inline_bound = rust_ir::InlineBound::TraitBound(trait_bound);
502 chalk_ir::Binders::empty(Interner, inline_bound)
504 bounds.extend(sized_bound);
505 bounds.shrink_to_fit();
508 // FIXME: Re-enable where clauses on associated types when an upstream chalk bug is fixed.
509 // (rust-analyzer#9052)
510 // let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
511 let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses: vec![] };
512 let datum = AssociatedTyDatum {
513 trait_id: to_chalk_trait_id(trait_),
516 binders: make_binders(db, &generic_params, bound_data),
521 pub(crate) fn trait_datum_query(
522 db: &dyn HirDatabase,
525 ) -> Arc<TraitDatum> {
526 debug!("trait_datum {:?}", trait_id);
527 let trait_ = from_chalk_trait_id(trait_id);
528 let trait_data = db.trait_data(trait_);
529 debug!("trait {:?} = {:?}", trait_id, trait_data.name);
530 let generic_params = generics(db.upcast(), trait_.into());
531 let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
532 let flags = rust_ir::TraitFlags {
533 auto: trait_data.is_auto,
534 upstream: trait_.lookup(db.upcast()).container.krate() != krate,
535 non_enumerable: true,
536 coinductive: false, // only relevant for Chalk testing
537 // FIXME: set these flags correctly
541 let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
542 let associated_ty_ids = trait_data.associated_types().map(to_assoc_type_id).collect();
543 let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses };
545 lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name));
546 let trait_datum = TraitDatum {
548 binders: make_binders(db, &generic_params, trait_datum_bound),
553 Arc::new(trait_datum)
556 fn well_known_trait_from_lang_attr(name: &str) -> Option<WellKnownTrait> {
558 "clone" => WellKnownTrait::Clone,
559 "coerce_unsized" => WellKnownTrait::CoerceUnsized,
560 "copy" => WellKnownTrait::Copy,
561 "discriminant_kind" => WellKnownTrait::DiscriminantKind,
562 "dispatch_from_dyn" => WellKnownTrait::DispatchFromDyn,
563 "drop" => WellKnownTrait::Drop,
564 "fn" => WellKnownTrait::Fn,
565 "fn_mut" => WellKnownTrait::FnMut,
566 "fn_once" => WellKnownTrait::FnOnce,
567 "generator" => WellKnownTrait::Generator,
568 "sized" => WellKnownTrait::Sized,
569 "unpin" => WellKnownTrait::Unpin,
570 "unsize" => WellKnownTrait::Unsize,
575 fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str {
577 WellKnownTrait::Clone => "clone",
578 WellKnownTrait::CoerceUnsized => "coerce_unsized",
579 WellKnownTrait::Copy => "copy",
580 WellKnownTrait::DiscriminantKind => "discriminant_kind",
581 WellKnownTrait::DispatchFromDyn => "dispatch_from_dyn",
582 WellKnownTrait::Drop => "drop",
583 WellKnownTrait::Fn => "fn",
584 WellKnownTrait::FnMut => "fn_mut",
585 WellKnownTrait::FnOnce => "fn_once",
586 WellKnownTrait::Generator => "generator",
587 WellKnownTrait::Sized => "sized",
588 WellKnownTrait::Unpin => "unpin",
589 WellKnownTrait::Unsize => "unsize",
593 pub(crate) fn struct_datum_query(
594 db: &dyn HirDatabase,
597 ) -> Arc<StructDatum> {
598 debug!("struct_datum {:?}", struct_id);
599 let chalk_ir::AdtId(adt_id) = struct_id;
600 let generic_params = generics(db.upcast(), adt_id.into());
601 let upstream = adt_id.module(db.upcast()).krate() != krate;
602 let where_clauses = {
603 let generic_params = generics(db.upcast(), adt_id.into());
604 let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
605 convert_where_clauses(db, adt_id.into(), &bound_vars)
607 let flags = rust_ir::AdtFlags {
609 // FIXME set fundamental and phantom_data flags correctly
613 // FIXME provide enum variants properly (for auto traits)
614 let variant = rust_ir::AdtVariantDatum {
615 fields: Vec::new(), // FIXME add fields (only relevant for auto traits),
617 let struct_datum_bound = rust_ir::AdtDatumBound { variants: vec![variant], where_clauses };
618 let struct_datum = StructDatum {
619 // FIXME set ADT kind
620 kind: rust_ir::AdtKind::Struct,
622 binders: make_binders(db, &generic_params, struct_datum_bound),
625 Arc::new(struct_datum)
628 pub(crate) fn impl_datum_query(
629 db: &dyn HirDatabase,
632 ) -> Arc<ImplDatum> {
633 let _p = profile::span("impl_datum");
634 debug!("impl_datum {:?}", impl_id);
635 let impl_: hir_def::ImplId = from_chalk(db, impl_id);
636 impl_def_datum(db, krate, impl_id, impl_)
640 db: &dyn HirDatabase,
643 impl_id: hir_def::ImplId,
644 ) -> Arc<ImplDatum> {
647 // ImplIds for impls where the trait ref can't be resolved should never reach Chalk
648 .expect("invalid impl passed to Chalk")
649 .into_value_and_skipped_binders()
651 let impl_data = db.impl_data(impl_id);
653 let generic_params = generics(db.upcast(), impl_id.into());
654 let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
655 let trait_ = trait_ref.hir_trait_id();
656 let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
657 rust_ir::ImplType::Local
659 rust_ir::ImplType::External
661 let where_clauses = convert_where_clauses(db, impl_id.into(), &bound_vars);
662 let negative = impl_data.is_negative;
664 "impl {:?}: {}{} where {:?}",
666 if negative { "!" } else { "" },
667 trait_ref.display(db),
671 let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
673 let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses };
674 let trait_data = db.trait_data(trait_);
675 let associated_ty_value_ids = impl_data
678 .filter_map(|item| match item {
679 AssocItemId::TypeAliasId(type_alias) => Some(*type_alias),
682 .filter(|&type_alias| {
683 // don't include associated types that don't exist in the trait
684 let name = &db.type_alias_data(type_alias).name;
685 trait_data.associated_type_by_name(name).is_some()
687 .map(|type_alias| TypeAliasAsValue(type_alias).to_chalk(db))
689 debug!("impl_datum: {:?}", impl_datum_bound);
690 let impl_datum = ImplDatum {
691 binders: make_binders(db, &generic_params, impl_datum_bound),
694 associated_ty_value_ids,
699 pub(crate) fn associated_ty_value_query(
700 db: &dyn HirDatabase,
702 id: AssociatedTyValueId,
703 ) -> Arc<AssociatedTyValue> {
704 let type_alias: TypeAliasAsValue = from_chalk(db, id);
705 type_alias_associated_ty_value(db, krate, type_alias.0)
708 fn type_alias_associated_ty_value(
709 db: &dyn HirDatabase,
711 type_alias: TypeAliasId,
712 ) -> Arc<AssociatedTyValue> {
713 let type_alias_data = db.type_alias_data(type_alias);
714 let impl_id = match type_alias.lookup(db.upcast()).container {
715 ItemContainerId::ImplId(it) => it,
716 _ => panic!("assoc ty value should be in impl"),
721 .expect("assoc ty value should not exist")
722 .into_value_and_skipped_binders()
723 .0; // we don't return any assoc ty values if the impl'd trait can't be resolved
726 .trait_data(trait_ref.hir_trait_id())
727 .associated_type_by_name(&type_alias_data.name)
728 .expect("assoc ty value should not exist"); // validated when building the impl data as well
729 let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders();
730 let value_bound = rust_ir::AssociatedTyValueBound { ty };
731 let value = rust_ir::AssociatedTyValue {
732 impl_id: impl_id.to_chalk(db),
733 associated_ty_id: to_assoc_type_id(assoc_ty),
734 value: chalk_ir::Binders::new(binders, value_bound),
739 pub(crate) fn fn_def_datum_query(
740 db: &dyn HirDatabase,
743 ) -> Arc<FnDefDatum> {
744 let callable_def: CallableDefId = from_chalk(db, fn_def_id);
745 let generic_params = generics(db.upcast(), callable_def.into());
746 let (sig, binders) = db.callable_item_signature(callable_def).into_value_and_skipped_binders();
747 let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
748 let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
749 let bound = rust_ir::FnDefDatumBound {
750 // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
751 inputs_and_output: chalk_ir::Binders::empty(
753 rust_ir::FnDefInputsAndOutputDatum {
754 argument_types: sig.params().to_vec(),
755 return_type: sig.ret().clone(),
757 .shifted_in(Interner),
761 let datum = FnDefDatum {
763 sig: chalk_ir::FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: sig.is_varargs },
764 binders: chalk_ir::Binders::new(binders, bound),
769 pub(crate) fn fn_def_variance_query(db: &dyn HirDatabase, fn_def_id: FnDefId) -> Variances {
770 let callable_def: CallableDefId = from_chalk(db, fn_def_id);
771 let generic_params = generics(db.upcast(), callable_def.into());
772 Variances::from_iter(
774 std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()),
778 pub(crate) fn adt_variance_query(
779 db: &dyn HirDatabase,
780 chalk_ir::AdtId(adt_id): AdtId,
782 let generic_params = generics(db.upcast(), adt_id.into());
783 Variances::from_iter(
785 std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()),
789 pub(super) fn convert_where_clauses(
790 db: &dyn HirDatabase,
792 substs: &Substitution,
793 ) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> {
794 let generic_predicates = db.generic_predicates(def);
795 let mut result = Vec::with_capacity(generic_predicates.len());
796 for pred in generic_predicates.iter() {
797 result.push(pred.clone().substitute(Interner, substs));
802 pub(super) fn generic_predicate_to_inline_bound(
803 db: &dyn HirDatabase,
804 pred: &QuantifiedWhereClause,
806 ) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
807 // An InlineBound is like a GenericPredicate, except the self type is left out.
808 // We don't have a special type for this, but Chalk does.
809 let self_ty_shifted_in = self_ty.clone().shifted_in_from(Interner, DebruijnIndex::ONE);
810 let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
812 WhereClause::Implemented(trait_ref) => {
813 if trait_ref.self_type_parameter(Interner) != self_ty_shifted_in {
814 // we can only convert predicates back to type bounds if they
815 // have the expected self type
818 let args_no_self = trait_ref.substitution.as_slice(Interner)[1..]
820 .map(|ty| ty.clone().cast(Interner))
822 let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
823 Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
825 WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
826 let trait_ = projection_ty.trait_(db);
827 if projection_ty.self_type_parameter(db) != self_ty_shifted_in {
830 let args_no_self = projection_ty.substitution.as_slice(Interner)[1..]
832 .map(|ty| ty.clone().cast(Interner))
834 let alias_eq_bound = rust_ir::AliasEqBound {
836 trait_bound: rust_ir::TraitBound {
837 trait_id: to_chalk_trait_id(trait_),
840 associated_ty_id: projection_ty.associated_ty_id,
841 parameters: Vec::new(), // FIXME we don't support generic associated types yet
843 Some(chalk_ir::Binders::new(
845 rust_ir::InlineBound::AliasEqBound(alias_eq_bound),