Refactor evaluator to reduce stack use

compiler/qsc/Cargo.toml

@@ -26,10 +26,25 @@ thiserror = { workspace = true }
 criterion = { workspace = true, features = ["cargo_bench_support"] }
 indoc = { workspace = true }
 
+[lib]
+bench = false
+
+[[bin]]
+name = "qsc"
+bench = false
+
+[[bin]]
+name = "qsi"
+bench = false
+
 [[bench]]
 name = "nqueens"
 harness = false
 
 [[bench]]
 name = "library"
 harness = false
+
+[[bench]]
+name = "eval"
+harness = false

compiler/qsc/benches/eval.rs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use qsc::interpret::stateless;
+use qsc_eval::output::GenericReceiver;
+use qsc_frontend::compile::SourceMap;
+
+const TELEPORT: &str = include_str!("../../../samples/Teleportation.qs");
+const DEUTSCHJOZSA: &str = include_str!("../../../samples/DeutschJozsa.qs");
+
+pub fn teleport(c: &mut Criterion) {
+    c.bench_function("Teleport evaluation", |b| {
+        let sources = SourceMap::new([("Teleportation.qs".into(), TELEPORT.into())], None);
+        let evaluator = stateless::Context::new(true, sources).expect("code should compile");
+        b.iter(move || {
+            let mut out = Vec::new();
+            let mut rec = GenericReceiver::new(&mut out);
+            assert!(evaluator.eval(&mut rec).is_ok());
+        })
+    });
+}
+
+pub fn deutsch_jozsa(c: &mut Criterion) {
+    c.bench_function("Deutsch-Jozsa evaluation", |b| {
+        let sources = SourceMap::new([("DeutschJozsa.qs".into(), DEUTSCHJOZSA.into())], None);
+        let evaluator = stateless::Context::new(true, sources).expect("code should compile");
+        b.iter(move || {
+            let mut out = Vec::new();
+            let mut rec = GenericReceiver::new(&mut out);
+            assert!(evaluator.eval(&mut rec).is_ok());
+        })
+    });
+}
+
+criterion_group!(benches, teleport, deutsch_jozsa);
+criterion_main!(benches);

compiler/qsc/src/compile.rs

@@ -4,8 +4,8 @@
 use crate::error::WithSource;
 use miette::{Diagnostic, Report};
 use qsc_frontend::compile::{CompileUnit, PackageStore, SourceMap};
-use qsc_hir::{global, hir::PackageId};
-use qsc_passes::run_default_passes;
+use qsc_hir::hir::PackageId;
+use qsc_passes::{run_core_passes, run_default_passes};
 use thiserror::Error;
 
 #[derive(Clone, Debug, Diagnostic, Error)]
@@ -45,18 +45,8 @@ pub fn compile(
 #[must_use]
 pub fn core() -> CompileUnit {
     let mut unit = qsc_frontend::compile::core();
-    let table = global::iter_package(None, &unit.package).collect();
-    let pass_errors = run_default_passes(&table, &mut unit);
-    if pass_errors.is_empty() {
-        unit
-    } else {
-        for error in pass_errors {
-            let report = Report::new(WithSource::from_map(&unit.sources, error, None));
-            eprintln!("{report:?}");
-        }
-
-        panic!("could not compile core library")
-    }
+    run_core_passes(&mut unit);
+    unit
 }
 
 /// Compiles the standard library.

compiler/qsc/src/interpret/stateful/tests.rs

@@ -222,6 +222,23 @@ mod given_interpreter {
             );
             is_unit_with_output(&result, &output, "before\nafter");
         }
+
+        #[test]
+        fn global_qubits() {
+            let mut interpreter = get_interpreter();
+            let (result, output) = line(&mut interpreter, "open Microsoft.Quantum.Diagnostics;");
+            is_only_value(&result, &output, &Value::unit());
+            let (result, output) = line(&mut interpreter, "DumpMachine()");
+            is_unit_with_output(&result, &output, "STATE:\n|0⟩: 1+0i");
+            let (result, output) = line(&mut interpreter, "use (q0, qs) = (Qubit(), Qubit[3]);");
+            is_only_value(&result, &output, &Value::unit());
+            let (result, output) = line(&mut interpreter, "DumpMachine()");
+            is_unit_with_output(&result, &output, "STATE:\n|0000⟩: 1+0i");
+            let (result, output) = line(&mut interpreter, "X(q0); X(qs[1]);");
+            is_only_value(&result, &output, &Value::unit());
+            let (result, output) = line(&mut interpreter, "DumpMachine()");
+            is_unit_with_output(&result, &output, "STATE:\n|0101⟩: 1+0i");
+        }
     }
 
     #[cfg(test)]