stepwise interpretation

src/interpreter/iterator.rs

@@ -0,0 +1,92 @@
+use super::{
+    FnEvalContext,
+    CachedMir,
+    TerminatorTarget,
+};
+use error::EvalResult;
+use rustc::mir::repr as mir;
+
+pub enum Event<'a, 'tcx: 'a> {
+    Assignment(&'a mir::Statement<'tcx>),
+    Terminator(&'a mir::Terminator<'tcx>),
+    Done,
+}
+
+pub struct Stepper<'fncx, 'a: 'fncx, 'b: 'a + 'mir, 'mir: 'fncx, 'tcx: 'b>{
+    fncx: &'fncx mut FnEvalContext<'a, 'b, 'mir, 'tcx>,
+    block: mir::BasicBlock,
+    stmt: usize,
+    mir: CachedMir<'mir, 'tcx>,
+    process: fn (&mut Stepper<'fncx, 'a, 'b, 'mir, 'tcx>) -> EvalResult<()>,
+}
+
+impl<'fncx, 'a, 'b: 'a + 'mir, 'mir, 'tcx: 'b> Stepper<'fncx, 'a, 'b, 'mir, 'tcx> {
+    pub(super) fn new(fncx: &'fncx mut FnEvalContext<'a, 'b, 'mir, 'tcx>) -> Self {
+        Stepper {
+            block: fncx.frame().next_block,
+            mir: fncx.mir(),
+            fncx: fncx,
+            stmt: 0,
+            process: Self::dummy,
+        }
+    }
+    fn dummy(&mut self) -> EvalResult<()> { Ok(()) }
+    fn statement(&mut self) -> EvalResult<()> {
+        let block_data = self.mir.basic_block_data(self.block);
+        let stmt = &block_data.statements[self.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.stmt += 1;
+        Ok(())
+    }
+    fn terminator(&mut self) -> EvalResult<()> {
+        self.stmt = 0;
+        let term = {
+            let block_data = self.mir.basic_block_data(self.block);
+            let terminator = block_data.terminator();
+            let result = self.fncx.eval_terminator(terminator);
+            self.fncx.maybe_report(terminator.span, result)?
+        };
+        match term {
+            TerminatorTarget::Block(block) => {
+                self.block = block;
+            },
+            TerminatorTarget::Return => {
+                self.fncx.pop_stack_frame();
+                self.fncx.name_stack.pop();
+                if !self.fncx.stack.is_empty() {
+                    self.block = self.fncx.frame().next_block;
+                    self.mir = self.fncx.mir();
+                }
+            },
+            TerminatorTarget::Call => {
+                self.block = self.fncx.frame().next_block;
+                self.mir = self.fncx.mir();
+            },
+        }
+        Ok(())
+    }
+    pub fn step<'step>(&'step mut self) -> EvalResult<Event<'step, 'tcx>> {
+        (self.process)(self)?;
+
+        if self.fncx.stack.is_empty() {
+            // fuse the iterator
+            self.process = Self::dummy;
+            return Ok(Event::Done);
+        }
+
+        let basic_block = self.mir.basic_block_data(self.block);
+
+        if let Some(stmt) = basic_block.statements.get(self.stmt) {
+            self.process = Self::statement;
+            return Ok(Event::Assignment(&stmt));
+        }
+
+        self.process = Self::terminator;
+        Ok(Event::Terminator(basic_block.terminator()))
+    }
+    pub fn block(&self) -> mir::BasicBlock {
+        self.block
+    }
+}

src/interpreter/mod.rs

@@ -20,6 +20,8 @@ use error::{EvalError, EvalResult};
 use memory::{Memory, Pointer};
 use primval::{self, PrimVal};
 
+mod iterator;
+
 struct GlobalEvalContext<'a, 'tcx: 'a> {
     /// The results of the type checker, from rustc.
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
@@ -184,38 +186,22 @@ impl<'a, 'b, 'mir, 'tcx> FnEvalContext<'a, 'b, 'mir, 'tcx> {
     }
 
     fn run(&mut self) -> EvalResult<()> {
-        'outer: while !self.stack.is_empty() {
-            let mut current_block = self.frame().next_block;
-            let current_mir = self.mir();
+        let mut stepper = iterator::Stepper::new(self);
+        'outer: loop {
+            use self::iterator::Event::*;
+            trace!("// {:?}", stepper.block());
 
             loop {
-                trace!("// {:?}", current_block);
-                let block_data = current_mir.basic_block_data(current_block);
-
-                for stmt in &block_data.statements {
-                    trace!("{:?}", stmt);
-                    let mir::StatementKind::Assign(ref lvalue, ref rvalue) = stmt.kind;
-                    let result = self.eval_assignment(lvalue, rvalue);
-                    self.maybe_report(stmt.span, result)?;
-                }
-
-                let terminator = block_data.terminator();
-                trace!("{:?}", terminator.kind);
-
-                let result = self.eval_terminator(terminator);
-                match self.maybe_report(terminator.span, result)? {
-                    TerminatorTarget::Block(block) => current_block = block,
-                    TerminatorTarget::Return => {
-                        self.pop_stack_frame();
-                        self.name_stack.pop();
+                match stepper.step()? {
+                    Assignment(statement) => trace!("{:?}", statement),
+                    Terminator(terminator) => {
+                        trace!("{:?}", terminator.kind);
                         continue 'outer;
-                    }
-                    TerminatorTarget::Call => continue 'outer,
+                    },
+                    Done => return Ok(()),
                 }
             }
         }
-
-        Ok(())
     }
 
     fn push_stack_frame(&mut self, mir: CachedMir<'mir, 'tcx>, substs: &'tcx Substs<'tcx>,

src/lib.rs

@@ -6,6 +6,7 @@
     filling_drop,
     question_mark,
     rustc_private,
+    pub_restricted,
 )]
 
 // From rustc.