Merge pull request rust-lang#52 from oli-obk/vtable

Vtable

Author: solson

src/error.rs

@@ -40,6 +40,8 @@ pub enum EvalError<'tcx> {
         required: usize,
         has: usize,
     },
+    CalledClosureAsFunction,
+    VtableForArgumentlessMethod,
 }
 
 pub type EvalResult<'tcx, T> = Result<T, EvalError<'tcx>>;
@@ -88,6 +90,10 @@ impl<'tcx> Error for EvalError<'tcx> {
                 "reached the configured maximum number of stack frames",
             EvalError::AlignmentCheckFailed{..} =>
                 "tried to execute a misaligned read or write",
+            EvalError::CalledClosureAsFunction =>
+                "tried to call a closure through a function pointer",
+            EvalError::VtableForArgumentlessMethod =>
+                "tried to call a vtable function without arguments",
         }
     }
 

src/interpreter/mod.rs

@@ -23,6 +23,7 @@ use std::collections::HashMap;
 mod step;
 mod terminator;
 mod cast;
+mod vtable;
 
 pub struct EvalContext<'a, 'tcx: 'a> {
     /// The results of the type checker, from rustc.
@@ -108,7 +109,7 @@ struct Lvalue {
 enum LvalueExtra {
     None,
     Length(u64),
-    // TODO(solson): Vtable(memory::AllocId),
+    Vtable(Pointer),
     DowncastVariant(usize),
 }
 
@@ -569,6 +570,9 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                     LvalueExtra::Length(len) => {
                         self.memory.write_usize(extra, len)?;
                     }
+                    LvalueExtra::Vtable(ptr) => {
+                        self.memory.write_ptr(extra, ptr)?;
+                    },
                     LvalueExtra::DowncastVariant(..) =>
                         bug!("attempted to take a reference to an enum downcast lvalue"),
                 }
@@ -587,6 +591,8 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                     Unsize => {
                         let src = self.eval_operand(operand)?;
                         let src_ty = self.operand_ty(operand);
+                        let dest_ty = self.monomorphize(dest_ty, self.substs());
+                        assert!(self.type_is_fat_ptr(dest_ty));
                         let (ptr, extra) = self.get_fat_ptr(dest);
                         self.move_(src, ptr, src_ty)?;
                         let src_pointee_ty = pointee_type(src_ty).unwrap();
@@ -596,8 +602,22 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                             (&ty::TyArray(_, length), &ty::TySlice(_)) => {
                                 self.memory.write_usize(extra, length as u64)?;
                             }
-
-                            _ => return Err(EvalError::Unimplemented(format!("can't handle cast: {:?}", rvalue))),
+                            (&ty::TyTrait(_), &ty::TyTrait(_)) => {
+                                // For now, upcasts are limited to changes in marker
+                                // traits, and hence never actually require an actual
+                                // change to the vtable.
+                                let (_, src_extra) = self.get_fat_ptr(src);
+                                let src_extra = self.memory.read_ptr(src_extra)?;
+                                self.memory.write_ptr(extra, src_extra)?;
+                            },
+                            (_, &ty::TyTrait(ref data)) => {
+                                let trait_ref = data.principal.with_self_ty(self.tcx, src_pointee_ty);
+                                let trait_ref = self.tcx.erase_regions(&trait_ref);
+                                let vtable = self.get_vtable(trait_ref)?;
+                                self.memory.write_ptr(extra, vtable)?;
+                            },
+
+                            _ => bug!("invalid unsizing {:?} -> {:?}", src_ty, dest_ty),
                         }
                     }
 
@@ -638,8 +658,8 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                         ty::TyFnPtr(unsafe_fn_ty) => {
                             let src = self.eval_operand(operand)?;
                             let ptr = self.memory.read_ptr(src)?;
-                            let fn_def = self.memory.get_fn(ptr.alloc_id)?;
-                            let fn_ptr = self.memory.create_fn_ptr(fn_def.def_id, fn_def.substs, unsafe_fn_ty);
+                            let (def_id, substs, _) = self.memory.get_fn(ptr.alloc_id)?;
+                            let fn_ptr = self.memory.create_fn_ptr(def_id, substs, unsafe_fn_ty);
                             self.memory.write_ptr(dest, fn_ptr)?;
                         },
                         ref other => bug!("fn to unsafe fn cast on {:?}", other),
@@ -827,15 +847,18 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
                     Deref => {
                         let pointee_ty = pointee_type(base_ty).expect("Deref of non-pointer");
-                        self.memory.dump(base.ptr.alloc_id);
                         let ptr = self.memory.read_ptr(base.ptr)?;
                         let extra = match pointee_ty.sty {
                             ty::TySlice(_) | ty::TyStr => {
                                 let (_, extra) = self.get_fat_ptr(base.ptr);
                                 let len = self.memory.read_usize(extra)?;
                                 LvalueExtra::Length(len)
                             }
-                            ty::TyTrait(_) => unimplemented!(),
+                            ty::TyTrait(_) => {
+                                let (_, extra) = self.get_fat_ptr(base.ptr);
+                                let vtable = self.memory.read_ptr(extra)?;
+                                LvalueExtra::Vtable(vtable)
+                            },
                             _ => LvalueExtra::None,
                         };
                         return Ok(Lvalue { ptr: ptr, extra: extra });

src/interpreter/terminator.rs

@@ -12,7 +12,7 @@ use syntax::codemap::{DUMMY_SP, Span};
 
 use super::{EvalContext, IntegerExt};
 use error::{EvalError, EvalResult};
-use memory::{Pointer, FunctionDefinition};
+use memory::Pointer;
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
@@ -90,7 +90,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                     ty::TyFnPtr(bare_fn_ty) => {
                         let ptr = self.eval_operand(func)?;
                         let fn_ptr = self.memory.read_ptr(ptr)?;
-                        let FunctionDefinition { def_id, substs, fn_ty } = self.memory.get_fn(fn_ptr.alloc_id)?;
+                        let (def_id, substs, fn_ty) = self.memory.get_fn(fn_ptr.alloc_id)?;
                         if fn_ty != bare_fn_ty {
                             return Err(EvalError::FunctionPointerTyMismatch(fn_ty, bare_fn_ty));
                         }
@@ -172,21 +172,21 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 // TODO(solson): Adjust the first argument when calling a Fn or
                 // FnMut closure via FnOnce::call_once.
 
-                // Only trait methods can have a Self parameter.
-                let (resolved_def_id, resolved_substs) =
-                    if let Some(trait_id) = self.tcx.trait_of_item(def_id) {
-                        self.trait_method(trait_id, def_id, substs)
-                    } else {
-                        (def_id, substs)
-                    };
-
                 let mut arg_srcs = Vec::new();
                 for arg in args {
                     let src = self.eval_operand(arg)?;
                     let src_ty = self.operand_ty(arg);
                     arg_srcs.push((src, src_ty));
                 }
 
+                // Only trait methods can have a Self parameter.
+                let (resolved_def_id, resolved_substs) =
+                    if let Some(trait_id) = self.tcx.trait_of_item(def_id) {
+                        self.trait_method(trait_id, def_id, substs, arg_srcs.get_mut(0))?
+                    } else {
+                        (def_id, substs)
+                    };
+
                 if fn_ty.abi == Abi::RustCall && !args.is_empty() {
                     arg_srcs.pop();
                     let last_arg = args.last().unwrap();
@@ -464,7 +464,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         Ok(())
     }
 
-    fn fulfill_obligation(&self, trait_ref: ty::PolyTraitRef<'tcx>) -> traits::Vtable<'tcx, ()> {
+    pub(super) fn fulfill_obligation(&self, trait_ref: ty::PolyTraitRef<'tcx>) -> traits::Vtable<'tcx, ()> {
         // Do the initial selection for the obligation. This yields the shallow result we are
         // looking for -- that is, what specific impl.
         self.tcx.infer_ctxt(None, None, Reveal::All).enter(|infcx| {
@@ -491,8 +491,9 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         &self,
         trait_id: DefId,
         def_id: DefId,
-        substs: &'tcx Substs<'tcx>
-    ) -> (DefId, &'tcx Substs<'tcx>) {
+        substs: &'tcx Substs<'tcx>,
+        first_arg: Option<&mut (Pointer, Ty<'tcx>)>,
+    ) -> EvalResult<'tcx, (DefId, &'tcx Substs<'tcx>)> {
         let trait_ref = ty::TraitRef::from_method(self.tcx, trait_id, substs);
         let trait_ref = self.tcx.normalize_associated_type(&ty::Binder(trait_ref));
 
@@ -504,11 +505,11 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 // and those from the method:
                 let mth = get_impl_method(self.tcx, substs, impl_did, vtable_impl.substs, mname);
 
-                (mth.method.def_id, mth.substs)
+                Ok((mth.method.def_id, mth.substs))
             }
 
             traits::VtableClosure(vtable_closure) =>
-                (vtable_closure.closure_def_id, vtable_closure.substs.func_substs),
+                Ok((vtable_closure.closure_def_id, vtable_closure.substs.func_substs)),
 
             traits::VtableFnPointer(_fn_ty) => {
                 let _trait_closure_kind = self.tcx.lang_items.fn_trait_kind(trait_id).unwrap();
@@ -524,14 +525,22 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 // Callee::ptr(immediate_rvalue(llfn, fn_ptr_ty))
             }
 
-            traits::VtableObject(ref _data) => {
-                unimplemented!()
-                // Callee {
-                //     data: Virtual(traits::get_vtable_index_of_object_method(
-                //                   tcx, data, def_id)),
-                //                   ty: def_ty(tcx, def_id, substs)
-                // }
-            }
+            traits::VtableObject(ref data) => {
+                let idx = self.tcx.get_vtable_index_of_object_method(data, def_id);
+                if let Some(&mut(first_arg, ref mut first_ty)) = first_arg {
+                    let (_, vtable) = self.get_fat_ptr(first_arg);
+                    let vtable = self.memory.read_ptr(vtable)?;
+                    let idx = idx + 3;
+                    let offset = idx * self.memory.pointer_size();
+                    let fn_ptr = self.memory.read_ptr(vtable.offset(offset as isize))?;
+                    let (def_id, substs, ty) = self.memory.get_fn(fn_ptr.alloc_id)?;
+                    // FIXME: skip_binder is wrong for HKL
+                    *first_ty = ty.sig.skip_binder().inputs[0];
+                    Ok((def_id, substs))
+                } else {
+                    Err(EvalError::VtableForArgumentlessMethod)
+                }
+            },
             vtable => bug!("resolved vtable bad vtable {:?} in trans", vtable),
         }
     }
@@ -566,14 +575,14 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 }
 
 #[derive(Debug)]
-struct ImplMethod<'tcx> {
-    method: Rc<ty::Method<'tcx>>,
-    substs: &'tcx Substs<'tcx>,
-    is_provided: bool,
+pub(super) struct ImplMethod<'tcx> {
+    pub(super) method: Rc<ty::Method<'tcx>>,
+    pub(super) substs: &'tcx Substs<'tcx>,
+    pub(super) is_provided: bool,
 }
 
 /// Locates the applicable definition of a method, given its name.
-fn get_impl_method<'a, 'tcx>(
+pub(super) fn get_impl_method<'a, 'tcx>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     substs: &'tcx Substs<'tcx>,
     impl_def_id: DefId,