rebase leftovers

diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
index 22db69a2afff8063359c005fd40d9914bad9fc46..c1a91fee79761feaf9012de01691e6684f337955 100644 (file)
--- a/src/interpreter/mod.rs
+++ b/src/interpreter/mod.rs
@@ -194,6 +194,7 @@ fn alloc_ret_ptr(&mut self, ty: ty::FnOutput<'tcx>, substs: &'tcx Substs<'tcx>)
             ty::FnDiverging => None,
         }
     }
+
     // TODO(solson): Try making const_to_primval instead.
     fn const_to_ptr(&mut self, const_val: &const_val::ConstVal) -> EvalResult<Pointer> {
         use rustc::middle::const_val::ConstVal::*;
@@ -337,6 +338,25 @@ fn load_mir(&self, def_id: DefId) -> CachedMir<'a, 'tcx> {
             }
         }
     }
+
+    fn monomorphize(&self, ty: Ty<'tcx>, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
+        let substituted = ty.subst(self.tcx, substs);
+        self.tcx.normalize_associated_type(&substituted)
+    }
+
+    fn type_size(&self, ty: Ty<'tcx>, substs: &'tcx Substs<'tcx>) -> usize {
+        self.type_layout(ty, substs).size(&self.tcx.data_layout).bytes() as usize
+    }
+
+    fn type_layout(&self, ty: Ty<'tcx>, substs: &'tcx Substs<'tcx>) -> &'tcx Layout {
+        // TODO(solson): Is this inefficient? Needs investigation.
+        let ty = self.monomorphize(ty, substs);
+
+        self.tcx.normalizing_infer_ctxt(ProjectionMode::Any).enter(|infcx| {
+            // TODO(solson): Report this error properly.
+            ty.layout(&infcx).unwrap()
+        })
+    }
 }
 
 impl<'a, 'b, 'mir, 'tcx> FnEvalContext<'a, 'b, 'mir, 'tcx> {
@@ -1308,49 +1328,6 @@ fn eval_lvalue(&mut self, lvalue: &mir::Lvalue<'tcx>) -> EvalResult<Lvalue> {
         Ok(Lvalue { ptr: ptr, extra: LvalueExtra::None })
     }
 
-    // TODO(solson): Try making const_to_primval instead.
-    fn const_to_ptr(&mut self, const_val: &const_val::ConstVal) -> EvalResult<Pointer> {
-        use rustc::middle::const_val::ConstVal::*;
-        match *const_val {
-            Float(_f) => unimplemented!(),
-            Integral(int) => {
-                // TODO(solson): Check int constant type.
-                let ptr = self.memory.allocate(8);
-                self.memory.write_uint(ptr, int.to_u64_unchecked(), 8)?;
-                Ok(ptr)
-            }
-            Str(ref s) => {
-                let psize = self.memory.pointer_size;
-                let static_ptr = self.memory.allocate(s.len());
-                let ptr = self.memory.allocate(psize * 2);
-                self.memory.write_bytes(static_ptr, s.as_bytes())?;
-                self.memory.write_ptr(ptr, static_ptr)?;
-                self.memory.write_usize(ptr.offset(psize as isize), s.len() as u64)?;
-                Ok(ptr)
-            }
-            ByteStr(ref bs) => {
-                let psize = self.memory.pointer_size;
-                let static_ptr = self.memory.allocate(bs.len());
-                let ptr = self.memory.allocate(psize);
-                self.memory.write_bytes(static_ptr, bs)?;
-                self.memory.write_ptr(ptr, static_ptr)?;
-                Ok(ptr)
-            }
-            Bool(b) => {
-                let ptr = self.memory.allocate(1);
-                self.memory.write_bool(ptr, b)?;
-                Ok(ptr)
-            }
-            Char(_c)          => unimplemented!(),
-            Struct(_node_id)  => unimplemented!(),
-            Tuple(_node_id)   => unimplemented!(),
-            Function(_def_id) => unimplemented!(),
-            Array(_, _)       => unimplemented!(),
-            Repeat(_, _)      => unimplemented!(),
-            Dummy             => unimplemented!(),
-        }
-    }
-
     fn lvalue_ty(&self, lvalue: &mir::Lvalue<'tcx>) -> Ty<'tcx> {
         self.monomorphize(self.mir().lvalue_ty(self.tcx, lvalue).to_ty(self.tcx))
     }
@@ -1360,12 +1337,7 @@ fn operand_ty(&self, operand: &mir::Operand<'tcx>) -> Ty<'tcx> {
     }
 
     fn monomorphize(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        let substituted = ty.subst(self.tcx, self.substs());
-        self.tcx.normalize_associated_type(&substituted)
-    }
-
-    fn type_needs_drop(&self, ty: Ty<'tcx>) -> bool {
-        self.tcx.type_needs_drop_given_env(ty, &self.tcx.empty_parameter_environment())
+        self.gecx.monomorphize(ty, self.substs())
     }
 
     fn move_(&mut self, src: Pointer, dest: Pointer, ty: Ty<'tcx>) -> EvalResult<()> {
@@ -1377,22 +1349,12 @@ fn move_(&mut self, src: Pointer, dest: Pointer, ty: Ty<'tcx>) -> EvalResult<()>
         Ok(())
     }
 
-    fn type_is_sized(&self, ty: Ty<'tcx>) -> bool {
-        ty.is_sized(self.tcx, &self.tcx.empty_parameter_environment(), DUMMY_SP)
-    }
-
     fn type_size(&self, ty: Ty<'tcx>) -> usize {
-        self.type_layout(ty).size(&self.tcx.data_layout).bytes() as usize
+        self.gecx.type_size(ty, self.substs())
     }
 
     fn type_layout(&self, ty: Ty<'tcx>) -> &'tcx Layout {
-        // TODO(solson): Is this inefficient? Needs investigation.
-        let ty = self.monomorphize(ty);
-
-        self.tcx.normalizing_infer_ctxt(ProjectionMode::Any).enter(|infcx| {
-            // TODO(solson): Report this error properly.
-            ty.layout(&infcx).unwrap()
-        })
+        self.gecx.type_layout(ty, self.substs())
     }
 
     pub fn read_primval(&mut self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult<PrimVal> {
@@ -1450,6 +1412,10 @@ fn frame_mut(&mut self) -> &mut Frame<'mir, 'tcx> {
     fn mir(&self) -> CachedMir<'mir, 'tcx> {
         self.frame().mir.clone()
     }
+
+    fn substs(&self) -> &'tcx Substs<'tcx> {
+        self.frame().substs
+    }
 }
 
 fn pointee_type(ptr_ty: ty::Ty) -> Option<ty::Ty> {

diff --git a/src/interpreter/stepper.rs b/src/interpreter/stepper.rs
index 8807dbcafab6a7f5383420594d7fdd5a2ade0c4e..fffac08fc6f4949304781fd3f35f5a4b6f9cffd5 100644 (file)
--- a/src/interpreter/stepper.rs
+++ b/src/interpreter/stepper.rs
@@ -3,7 +3,8 @@
     CachedMir,
     TerminatorTarget,
     ConstantId,
-    GlobalEvalContext
+    GlobalEvalContext,
+    Frame,
 };
 use error::EvalResult;
 use rustc::mir::repr as mir;
@@ -41,7 +42,7 @@ fn statement(&mut self) -> EvalResult<()> {
         let stmt = &block_data.statements[self.fncx.frame().stmt];
         let mir::StatementKind::Assign(ref lvalue, ref rvalue) = stmt.kind;
         let result = self.fncx.eval_assignment(lvalue, rvalue);
-        self.fncx.maybe_report(stmt.span, result)?;
+        self.fncx.maybe_report(result)?;
         self.fncx.frame_mut().stmt += 1;
         Ok(())
     }
@@ -54,7 +55,7 @@ fn terminator(&mut self) -> EvalResult<()> {
             let block_data = mir.basic_block_data(self.fncx.frame().next_block);
             let terminator = block_data.terminator();
             let result = self.fncx.eval_terminator(terminator);
-            self.fncx.maybe_report(terminator.span, result)?
+            self.fncx.maybe_report(result)?
         };
         match term {
             TerminatorTarget::Block => {},