Update for changes in rustc.

src/interpreter/mod.rs

@@ -771,7 +771,7 @@ fn get_field_ty(&self, ty: Ty<'tcx>, field_index: usize) -> EvalResult<'tcx, Ty<
                 match (field_index, &self.tcx.struct_tail(ty).sty) {
                     (1, &ty::TyStr) |
                     (1, &ty::TySlice(_)) => Ok(self.tcx.types.usize),
-                    (1, &ty::TyTrait(_)) |
+                    (1, &ty::TyDynamic(..)) |
                     (0, _) => Ok(self.tcx.mk_imm_ptr(self.tcx.types.u8)),
                     _ => bug!("invalid fat pointee type: {}", ty),
                 }
@@ -1009,7 +1009,7 @@ fn eval_lvalue_projection(
                 trace!("deref to {} on {:?}", pointee_type, val);
 
                 match self.tcx.struct_tail(pointee_type).sty {
-                    ty::TyTrait(_) => {
+                    ty::TyDynamic(..) => {
                         let (ptr, vtable) = val.expect_ptr_vtable_pair(&self.memory)?;
                         (ptr, LvalueExtra::Vtable(vtable))
                     },
@@ -1462,7 +1462,7 @@ fn try_read_value(&mut self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult<'tcx, Opt
                     trace!("reading fat pointer extra of type {}", ty);
                     let extra = ptr.offset(self.memory.pointer_size());
                     let extra = match self.tcx.struct_tail(ty).sty {
-                        ty::TyTrait(..) => PrimVal::from_ptr(self.memory.read_ptr(extra)?),
+                        ty::TyDynamic(..) => PrimVal::from_ptr(self.memory.read_ptr(extra)?),
                         ty::TySlice(..) |
                         ty::TyStr => PrimVal::from_uint(self.memory.read_usize(extra)?),
                         _ => bug!("unsized primval ptr read from {:?}", ty),
@@ -1529,14 +1529,14 @@ fn unsize_into(
                         let ptr = PrimVal::from_ptr(ptr);
                         self.write_value(Value::ByValPair(ptr, len), dest, dest_ty)?;
                     }
-                    (&ty::TyTrait(_), &ty::TyTrait(_)) => {
+                    (&ty::TyDynamic(..), &ty::TyDynamic(..)) => {
                         // For now, upcasts are limited to changes in marker
                         // traits, and hence never actually require an actual
                         // change to the vtable.
                         self.write_value(src, dest, dest_ty)?;
                     },
-                    (_, &ty::TyTrait(ref data)) => {
-                        let trait_ref = data.principal.with_self_ty(self.tcx, src_pointee_ty);
+                    (_, &ty::TyDynamic(ref data, _)) => {
+                        let trait_ref = data.principal().unwrap().with_self_ty(self.tcx, src_pointee_ty);
                         let trait_ref = self.tcx.erase_regions(&trait_ref);
                         let vtable = self.get_vtable(trait_ref)?;
                         let ptr = src.read_ptr(&self.memory)?;

src/interpreter/terminator/intrinsics.rs

@@ -182,7 +182,7 @@ pub(super) fn call_intrinsic(
                     Value::ByValPair(ptr, extra) => Lvalue::Ptr {
                         ptr: ptr.to_ptr(),
                         extra: match self.tcx.struct_tail(ty).sty {
-                            ty::TyTrait(_) => LvalueExtra::Vtable(extra.to_ptr()),
+                            ty::TyDynamic(..) => LvalueExtra::Vtable(extra.to_ptr()),
                             ty::TyStr | ty::TySlice(_) => LvalueExtra::Length(extra.try_as_uint()?),
                             _ => bug!("invalid fat pointer type: {}", ptr_ty),
                         },
@@ -465,7 +465,7 @@ fn size_and_align_of_dst(
                         Ok((size, align))
                     }
                 }
-                ty::TyTrait(..) => {
+                ty::TyDynamic(..) => {
                     let (_, vtable) = value.expect_ptr_vtable_pair(&self.memory)?;
                     // the second entry in the vtable is the dynamic size of the object.
                     let size = self.memory.read_usize(vtable.offset(pointer_size))?;

src/interpreter/terminator/mod.rs

@@ -550,7 +550,7 @@ pub fn drop(
                     Value::ByValPair(prim_ptr, extra) => {
                         let ptr = prim_ptr.to_ptr();
                         let extra = match self.tcx.struct_tail(contents_ty).sty {
-                            ty::TyTrait(_) => LvalueExtra::Vtable(extra.to_ptr()),
+                            ty::TyDynamic(..) => LvalueExtra::Vtable(extra.to_ptr()),
                             ty::TyStr | ty::TySlice(_) => LvalueExtra::Length(extra.try_as_uint()?),
                             _ => bug!("invalid fat pointer type: {}", ty),
                         };
@@ -640,7 +640,7 @@ pub fn drop(
                 };
                 self.drop_fields(fields.iter().cloned().zip(offsets.iter().cloned()), lval, drop)?;
             },
-            ty::TyTrait(_) => {
+            ty::TyDynamic(..) => {
                 let (ptr, vtable) = match lval {
                     Lvalue::Ptr { ptr, extra: LvalueExtra::Vtable(vtable) } => (ptr, vtable),
                     _ => bug!("expected an lvalue with a vtable"),