let it_def_id = ccx.tcx.map.local_def_id(it.id);
let variant = tcx.lookup_adt_def_master(it_def_id).struct_variant();
- for (f, ty_f) in struct_def.fields.iter().zip(variant.fields.iter()) {
+ for (f, ty_f) in struct_def.fields().zip(variant.fields.iter()) {
convert_field(ccx, &scheme.generics, &predicates, f, ty_f)
}
- if struct_def.kind != hir::VariantKind::Dict {
- convert_variant_ctor(tcx, struct_def.id, variant, scheme, predicates);
+ if !struct_def.is_struct() {
+ convert_variant_ctor(tcx, struct_def.id(), variant, scheme, predicates);
}
},
hir::ItemTy(_, ref generics) => {
scheme: ty::TypeScheme<'tcx>,
predicates: ty::GenericPredicates<'tcx>) {
let ctor_ty = match variant.kind() {
- VariantKind::Unit | VariantKind::Dict => scheme.ty,
+ VariantKind::Unit | VariantKind::Struct => scheme.ty,
VariantKind::Tuple => {
let inputs: Vec<_> =
variant.fields
variants: &[P<hir::Variant>]) {
// fill the field types
for (variant, ty_variant) in variants.iter().zip(def.variants.iter()) {
- for (f, ty_f) in variant.node.def.fields.iter().zip(ty_variant.fields.iter()) {
+ for (f, ty_f) in variant.node.data.fields().zip(ty_variant.fields.iter()) {
convert_field(ccx, &scheme.generics, &predicates, f, ty_f)
}
// an item.
convert_variant_ctor(
ccx.tcx,
- variant.node.def.id,
+ variant.node.data.id(),
ty_variant,
scheme.clone(),
predicates.clone()
did: DefId,
name: ast::Name,
disr_val: ty::Disr,
- def: &hir::StructDef) -> ty::VariantDefData<'tcx, 'tcx> {
+ def: &hir::VariantData) -> ty::VariantDefData<'tcx, 'tcx> {
let mut seen_fields: FnvHashMap<ast::Name, Span> = FnvHashMap();
- let fields = def.fields.iter().map(|f| {
+ let fields = def.fields().map(|f| {
let fid = tcx.map.local_def_id(f.node.id);
match f.node.kind {
hir::NamedField(name, vis) => {
fn convert_struct_def<'tcx>(tcx: &ty::ctxt<'tcx>,
it: &hir::Item,
- def: &hir::StructDef)
+ def: &hir::VariantData)
-> ty::AdtDefMaster<'tcx>
{
let did = tcx.map.local_def_id(it.id);
- let ctor_id = if def.kind != hir::VariantKind::Dict {
- tcx.map.local_def_id(def.id)
+ let ctor_id = if !def.is_struct() {
+ tcx.map.local_def_id(def.id())
} else {
did
};
disr: ty::Disr)
-> ty::VariantDefData<'tcx, 'tcx>
{
- let did = tcx.map.local_def_id(v.node.def.id);
+ let did = tcx.map.local_def_id(v.node.data.id());
let name = v.node.name;
- convert_struct_variant(tcx, did, name, disr, &v.node.def, did)
+ convert_struct_variant(tcx, did, name, disr, &v.node.data)
}
let did = tcx.map.local_def_id(it.id);
let repr_hints = tcx.lookup_repr_hints(did);