&self,
trait_id: chalk_ir::TraitId<RustInterner<'tcx>>,
) -> Arc<chalk_solve::rust_ir::TraitDatum<RustInterner<'tcx>>> {
+ use chalk_solve::rust_ir::WellKnownTrait::*;
+
let def_id = trait_id.0;
let trait_def = self.interner.tcx.trait_def(def_id);
let lang_items = self.interner.tcx.lang_items();
let well_known = if lang_items.sized_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::Sized)
+ Some(Sized)
} else if lang_items.copy_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::Copy)
+ Some(Copy)
} else if lang_items.clone_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::Clone)
+ Some(Clone)
} else if lang_items.drop_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::Drop)
+ Some(Drop)
} else if lang_items.fn_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::Fn)
+ Some(Fn)
} else if lang_items.fn_once_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::FnOnce)
+ Some(FnOnce)
} else if lang_items.fn_mut_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::FnMut)
+ Some(FnMut)
} else if lang_items.unsize_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::Unsize)
+ Some(Unsize)
} else if lang_items.unpin_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::Unpin)
+ Some(Unpin)
} else if lang_items.coerce_unsized_trait() == Some(def_id) {
- Some(chalk_solve::rust_ir::WellKnownTrait::CoerceUnsized)
+ Some(CoerceUnsized)
+ } else if lang_items.dispatch_from_dyn_trait() == Some(def_id) {
+ Some(DispatchFromDyn)
} else {
None
};
) -> Arc<chalk_solve::rust_ir::AdtDatum<RustInterner<'tcx>>> {
let adt_def = adt_id.0;
- let bound_vars = bound_vars_for_item(self.interner.tcx, adt_def.did);
+ let bound_vars = bound_vars_for_item(self.interner.tcx, adt_def.did());
let binders = binders_for(self.interner, bound_vars);
- let where_clauses = self.where_clauses_for(adt_def.did, bound_vars);
+ let where_clauses = self.where_clauses_for(adt_def.did(), bound_vars);
let variants: Vec<_> = adt_def
- .variants
+ .variants()
.iter()
.map(|variant| chalk_solve::rust_ir::AdtVariantDatum {
fields: variant
chalk_solve::rust_ir::AdtDatumBound { variants, where_clauses },
),
flags: chalk_solve::rust_ir::AdtFlags {
- upstream: !adt_def.did.is_local(),
+ upstream: !adt_def.did().is_local(),
fundamental: adt_def.is_fundamental(),
phantom_data: adt_def.is_phantom_data(),
},
let int = |i| chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Int(i)).intern(self.interner);
let uint = |i| chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Uint(i)).intern(self.interner);
Arc::new(chalk_solve::rust_ir::AdtRepr {
- c: adt_def.repr.c(),
- packed: adt_def.repr.packed(),
- int: adt_def.repr.int.map(|i| match i {
+ c: adt_def.repr().c(),
+ packed: adt_def.repr().packed(),
+ int: adt_def.repr().int.map(|i| match i {
attr::IntType::SignedInt(ty) => match ty {
ast::IntTy::Isize => int(chalk_ir::IntTy::Isize),
ast::IntTy::I8 => int(chalk_ir::IntTy::I8),
})
}
+ fn adt_size_align(
+ &self,
+ adt_id: chalk_ir::AdtId<RustInterner<'tcx>>,
+ ) -> Arc<chalk_solve::rust_ir::AdtSizeAlign> {
+ let tcx = self.interner.tcx;
+ let did = adt_id.0.did();
+
+ // Grab the ADT and the param we might need to calculate its layout
+ let param_env = tcx.param_env(did);
+ let adt_ty = tcx.type_of(did);
+
+ // The ADT is a 1-zst if it's a ZST and its alignment is 1.
+ // Mark the ADT as _not_ a 1-zst if there was a layout error.
+ let one_zst = if let Ok(layout) = tcx.layout_of(param_env.and(adt_ty)) {
+ layout.is_zst() && layout.align.abi.bytes() == 1
+ } else {
+ false
+ };
+
+ Arc::new(chalk_solve::rust_ir::AdtSizeAlign::from_one_zst(one_zst))
+ }
+
fn fn_def_datum(
&self,
fn_def_id: chalk_ir::FnDefId<RustInterner<'tcx>>,
let trait_ref = self.interner.tcx.impl_trait_ref(impl_def_id).unwrap();
let self_ty = trait_ref.self_ty();
let provides = match (self_ty.kind(), chalk_ty) {
- (&ty::Adt(impl_adt_def, ..), Adt(id, ..)) => impl_adt_def.did == id.0.did,
+ (&ty::Adt(impl_adt_def, ..), Adt(id, ..)) => impl_adt_def.did() == id.0.did(),
(_, AssociatedType(_ty_id, ..)) => {
// FIXME(chalk): See https://github.com/rust-lang/rust/pull/77152#discussion_r494484774
false
Unpin => lang_items.unpin_trait(),
CoerceUnsized => lang_items.coerce_unsized_trait(),
DiscriminantKind => lang_items.discriminant_kind_trait(),
+ DispatchFromDyn => lang_items.dispatch_from_dyn_trait(),
};
def_id.map(chalk_ir::TraitId)
}
&self,
adt_id: chalk_ir::AdtId<RustInterner<'tcx>>,
) -> chalk_ir::Variances<RustInterner<'tcx>> {
- let variances = self.interner.tcx.variances_of(adt_id.0.did);
+ let variances = self.interner.tcx.variances_of(adt_id.0.did());
chalk_ir::Variances::from_iter(
self.interner,
variances.iter().map(|v| v.lower_into(self.interner)),