VtableObject(VtableObjectData<'tcx, N>),
/// Successful resolution for a builtin trait.
- VtableBuiltin(VtableBuiltinData<'tcx, N>),
+ VtableBuiltin(VtableBuiltinData<N>),
/// Vtable automatically generated for a closure. The def ID is the ID
/// of the closure expression. This is a `VtableImpl` in spirit, but the
}
#[derive(Clone)]
-pub struct VtableBuiltinData<'tcx, N> {
- /// `ty` can be used for generating shim for builtin implementations like `Clone::clone`.
- pub ty: ty::Ty<'tcx>,
+pub struct VtableBuiltinData<N> {
pub nested: Vec<N>
}
}),
VtableParam(n) => VtableParam(n.into_iter().map(f).collect()),
VtableBuiltin(i) => VtableBuiltin(VtableBuiltinData {
- ty: i.ty,
nested: i.nested.into_iter().map(f).collect(),
}),
VtableObject(o) => VtableObject(VtableObjectData {
fn confirm_builtin_candidate(&mut self,
obligation: &TraitObligation<'tcx>,
has_nested: bool)
- -> VtableBuiltinData<'tcx, PredicateObligation<'tcx>>
+ -> VtableBuiltinData<PredicateObligation<'tcx>>
{
debug!("confirm_builtin_candidate({:?}, {:?})",
obligation, has_nested);
debug!("confirm_builtin_candidate: obligations={:?}",
obligations);
- let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty());
- VtableBuiltinData { ty: self_ty, nested: obligations }
+ VtableBuiltinData { nested: obligations }
}
/// This handles the case where a `impl Foo for ..` impl is being used.
fn confirm_builtin_unsize_candidate(&mut self,
obligation: &TraitObligation<'tcx>,)
- -> Result<VtableBuiltinData<'tcx, PredicateObligation<'tcx>>, SelectionError<'tcx>>
+ -> Result<VtableBuiltinData<PredicateObligation<'tcx>>, SelectionError<'tcx>>
{
let tcx = self.tcx();
_ => bug!()
};
- Ok(VtableBuiltinData { ty: source, nested: nested })
+ Ok(VtableBuiltinData { nested: nested })
}
///////////////////////////////////////////////////////////////////////////
}
}
-impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableBuiltinData<'tcx, N> {
+impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableBuiltinData<N> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "VtableBuiltin(ty={:?}, nested={:?})", self.ty, self.nested)
+ write!(f, "VtableBuiltin(nested={:?})", self.nested)
}
}
})
}
traits::VtableParam(n) => Some(traits::VtableParam(n)),
- traits::VtableBuiltin(traits::VtableBuiltinData { ty, nested }) => {
- tcx.lift(&ty).map(|ty| {
- traits::VtableBuiltin(traits::VtableBuiltinData {
- ty,
- nested,
- })
- })
- }
+ traits::VtableBuiltin(n) => Some(traits::VtableBuiltin(n)),
traits::VtableObject(traits::VtableObjectData {
upcast_trait_ref,
vtable_base,
}
}
-impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableBuiltinData<'tcx, N> {
+impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableBuiltinData<N> {
fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
traits::VtableBuiltinData {
- ty: self.ty.fold_with(folder),
nested: self.nested.fold_with(folder),
}
}
/// Build a `Clone::clone` shim for `recvr_ty`. Here, `def_id` is `Clone::clone`.
fn build_clone_shim<'a, 'tcx>(tcx: ty::TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId,
- recvr_ty: ty::Ty<'tcx>)
+ rcvr_ty: ty::Ty<'tcx>)
-> Mir<'tcx>
{
let sig = tcx.fn_sig(def_id);
loc
};
- match recvr_ty.sty {
+ match rcvr_ty.sty {
ty::TyArray(ty, len) => {
let mut returns = Vec::new();
for i in 0..len {
Lvalue::Local(RETURN_POINTER),
Rvalue::Aggregate(
box AggregateKind::Array(ty),
- returns.into_iter().map(|loc| Operand::Consume(loc)).collect()
+ returns.into_iter().map(Operand::Consume).collect()
)
)
};
Lvalue::Local(RETURN_POINTER),
Rvalue::Aggregate(
box AggregateKind::Tuple,
- returns.into_iter().map(|loc| Operand::Consume(loc)).collect()
+ returns.into_iter().map(Operand::Consume).collect()
)
)
};
substs: rcvr_substs
}
}
- traits::VtableBuiltin(ref data) => {
+ traits::VtableBuiltin(..) => {
Instance {
- def: ty::InstanceDef::BuiltinShim(def_id, data.ty),
+ def: ty::InstanceDef::BuiltinShim(def_id, trait_ref.self_ty()),
substs: rcvr_substs
}
}