Support partial evaluation of sub graphs, add tests

Author: swernli

compiler/qsc_eval/src/intrinsic/tests.rs

@@ -7,7 +7,8 @@ use std::f64::consts;
 
 use crate::backend::{Backend, SparseSim};
 use crate::debug::map_hir_package_to_fir;
-use crate::tests::eval_expr;
+use crate::tests::eval_cfg;
+use crate::Env;
 use crate::{
     output::{GenericReceiver, Receiver},
     val::Value,
@@ -192,11 +193,12 @@ fn check_intrinsic(file: &str, expr: &str, out: &mut impl Receiver) -> Result<Va
     fir_store.insert(map_hir_package_to_fir(std_id), std_fir);
     fir_store.insert(map_hir_package_to_fir(id), unit_fir);
 
-    eval_expr(
+    eval_cfg(
         entry,
         &mut CustomSim::default(),
         &fir_store,
         map_hir_package_to_fir(id),
+        &mut Env::default(),
         out,
     )
     .map_err(|e| e.0)

compiler/qsc_eval/src/lib.rs

@@ -28,6 +28,7 @@ use qsc_fir::fir::{
 };
 use qsc_fir::ty::Ty;
 use rand::{rngs::StdRng, SeedableRng};
+use std::ops;
 use std::{
     cell::RefCell,
     fmt::{self, Display, Formatter},
@@ -172,6 +173,26 @@ impl Display for Spec {
     }
 }
 
+/// Utility function to identify a subset of a control flow graph corresponding to a given
+/// range.
+#[must_use]
+pub fn sub_cfg(cfg: &Rc<[CfgNode]>, range: ops::Range<usize>) -> Rc<[CfgNode]> {
+    let start: u32 = range
+        .start
+        .try_into()
+        .expect("cfg ranges should fit into u32");
+    cfg[range]
+        .iter()
+        .map(|node| match node {
+            CfgNode::Jump(idx) => CfgNode::Jump(idx - start),
+            CfgNode::JumpIf(idx) => CfgNode::JumpIf(idx - start),
+            CfgNode::JumpIfNot(idx) => CfgNode::JumpIfNot(idx - start),
+            _ => *node,
+        })
+        .collect::<Vec<_>>()
+        .into()
+}
+
 /// Evaluates the given code with the given context.
 /// # Errors
 /// Returns the first error encountered during execution.
@@ -480,24 +501,20 @@ impl State {
             let cfg = self
                 .cfg_stack
                 .last()
-                .expect("should have at least one stack frame")
-                .clone();
-            let res = match cfg
-                .get(self.idx as usize)
-                .expect("should have next node in CFG")
-            {
-                CfgNode::Bind(pat) => {
+                .expect("should have at least one stack frame");
+            let res = match cfg.get(self.idx as usize) {
+                Some(CfgNode::Bind(pat)) => {
                     self.idx += 1;
                     self.eval_bind(env, globals, *pat);
                     continue;
                 }
-                CfgNode::Expr(expr) => {
+                Some(CfgNode::Expr(expr)) => {
                     self.idx += 1;
                     self.eval_expr(env, sim, globals, out, *expr)
                         .map_err(|e| (e, self.get_stack_frames()))?;
                     continue;
                 }
-                CfgNode::Stmt(stmt) => {
+                Some(CfgNode::Stmt(stmt)) => {
                     self.idx += 1;
                     self.current_span = globals.get_stmt((self.package, *stmt).into()).span;
 
@@ -521,11 +538,11 @@ impl State {
                         }
                     }
                 }
-                CfgNode::Jump(idx) => {
+                Some(CfgNode::Jump(idx)) => {
                     self.idx = *idx;
                     continue;
                 }
-                CfgNode::JumpIf(idx) => {
+                Some(CfgNode::JumpIf(idx)) => {
                     let cond = self.curr_val == Some(Value::Bool(true));
                     if cond {
                         self.idx = *idx;
@@ -534,7 +551,7 @@ impl State {
                     }
                     continue;
                 }
-                CfgNode::JumpIfNot(idx) => {
+                Some(CfgNode::JumpIfNot(idx)) => {
                     let cond = self.curr_val == Some(Value::Bool(true));
                     if cond {
                         self.idx += 1;
@@ -543,21 +560,30 @@ impl State {
                     }
                     continue;
                 }
-                CfgNode::Store => {
+                Some(CfgNode::Store) => {
                     self.push_val();
                     self.idx += 1;
                     continue;
                 }
-                CfgNode::Unit => {
+                Some(CfgNode::Unit) => {
                     self.idx += 1;
                     self.set_curr_val(Value::unit());
                     continue;
                 }
-                CfgNode::Ret => {
+                Some(CfgNode::Ret) => {
                     self.leave_frame();
                     env.leave_scope();
                     continue;
                 }
+                None => {
+                    // We have reached the end of the current cfg without reaching an explicit return node,
+                    // usually indicating the partial execution of a single sub-expression.
+                    // This means we should leave the current frame but not the current environment scope,
+                    // so bound variables are still accessible after completion.
+                    self.leave_frame();
+                    assert!(self.cfg_stack.is_empty());
+                    continue;
+                }
             };
 
             if let StepResult::Return(_) = res {

compiler/qsc_eval/src/lower.rs

@@ -267,6 +267,7 @@ impl Lowerer {
 
     fn lower_stmt(&mut self, stmt: &hir::Stmt) -> fir::StmtId {
         let id = self.assigner.next_stmt();
+        let cfg_start_idx = self.cfg.len();
         self.cfg.push(CfgNode::Stmt(id));
         let kind = match &stmt.kind {
             hir::StmtKind::Expr(expr) => fir::StmtKind::Expr(self.lower_expr(expr)),
@@ -289,6 +290,7 @@ impl Lowerer {
             id,
             span: stmt.span,
             kind,
+            cfg_range: cfg_start_idx..self.cfg.len(),
         };
         self.stmts.insert(id, stmt);
         id
@@ -297,6 +299,7 @@ impl Lowerer {
     #[allow(clippy::too_many_lines)]
     fn lower_expr(&mut self, expr: &hir::Expr) -> ExprId {
         let id = self.assigner.next_expr();
+        let cfg_start_idx = self.cfg.len();
         let ty = self.lower_ty(&expr.ty);
 
         let kind = match &expr.kind {
@@ -572,6 +575,7 @@ impl Lowerer {
             span: expr.span,
             ty,
             kind,
+            cfg_range: cfg_start_idx..self.cfg.len(),
         };
         self.exprs.insert(id, expr);
         id