Depend on use-stmt transform, skip qubit tracking

Author: swernli

compiler/qsc/src/compile.rs

@@ -5,7 +5,7 @@ use crate::error::WithSource;
 use miette::{Diagnostic, Report};
 use qsc_frontend::compile::{CompileUnit, PackageStore, SourceMap};
 use qsc_hir::hir::PackageId;
-use qsc_passes::run_default_passes;
+use qsc_passes::{run_core_passes, run_default_passes};
 use thiserror::Error;
 
 #[derive(Clone, Debug, Diagnostic, Error)]
@@ -29,7 +29,7 @@ pub fn compile(
     }
 
     if errors.is_empty() {
-        for error in run_default_passes(&mut unit) {
+        for error in run_default_passes(&mut unit, store) {
             errors.push(error.into());
         }
     }
@@ -45,17 +45,8 @@ pub fn compile(
 #[must_use]
 pub fn core() -> CompileUnit {
     let mut unit = qsc_frontend::compile::core();
-    let pass_errors = run_default_passes(&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.
@@ -66,7 +57,7 @@ pub fn core() -> CompileUnit {
 #[must_use]
 pub fn std(store: &PackageStore) -> CompileUnit {
     let mut unit = qsc_frontend::compile::std(store);
-    let pass_errors = run_default_passes(&mut unit);
+    let pass_errors = run_default_passes(&mut unit, store);
     if pass_errors.is_empty() {
         unit
     } else {

compiler/qsc_eval/src/intrinsic.rs

@@ -150,7 +150,11 @@ pub(crate) fn invoke_intrinsic(
             }
 
             "__quantum__rt__qubit_release" => {
-                __quantum__rt__qubit_release(args.into_qubit().0);
+                let qubit = args.into_qubit().0;
+                if !qubit_is_zero(qubit) {
+                    return Err(Error::ReleasedQubitNotZero(qubit as usize));
+                }
+                __quantum__rt__qubit_release(qubit);
                 Ok(Value::unit())
             }
 

compiler/qsc_eval/src/intrinsic/tests.rs

@@ -7,7 +7,7 @@ use expect_test::{expect, Expect};
 use indoc::indoc;
 use num_bigint::BigInt;
 use qsc_frontend::compile::{self, compile, PackageStore, SourceMap};
-use qsc_passes::run_default_passes;
+use qsc_passes::{run_core_passes, run_default_passes};
 
 use crate::{
     eval_expr,
@@ -18,16 +18,18 @@ use crate::{
 };
 
 fn check_intrinsic(file: &str, expr: &str, out: &mut dyn Receiver) -> Result<Value, Error> {
-    let mut store = PackageStore::new(compile::core());
+    let mut core = compile::core();
+    run_core_passes(&mut core);
+    let mut store = PackageStore::new(core);
     let mut std = compile::std(&store);
     assert!(std.errors.is_empty());
-    assert!(run_default_passes(&mut std).is_empty());
+    assert!(run_default_passes(&mut std, &store).is_empty());
 
     let std_id = store.insert(std);
     let sources = SourceMap::new([("test".into(), file.into())], Some(expr.into()));
     let mut unit = compile(&store, &[std_id], sources);
     assert!(unit.errors.is_empty());
-    assert!(run_default_passes(&mut unit).is_empty());
+    assert!(run_default_passes(&mut unit, &store).is_empty());
 
     let id = store.insert(unit);
     let entry = store
@@ -874,10 +876,6 @@ fn qubit_release_non_zero_failure() {
         &expect![[r#"
             ReleasedQubitNotZero(
                 0,
-                Span {
-                    lo: 14,
-                    hi: 21,
-                },
             )
         "#]],
     );

compiler/qsc_eval/src/lib.rs

@@ -17,15 +17,12 @@ use intrinsic::invoke_intrinsic;
 use miette::Diagnostic;
 use num_bigint::BigInt;
 use output::Receiver;
-use qir_backend::{
-    __quantum__rt__initialize, __quantum__rt__qubit_allocate, __quantum__rt__qubit_release,
-    qubit_is_zero,
-};
+use qir_backend::__quantum__rt__initialize;
 use qsc_data_structures::span::Span;
 use qsc_hir::hir::{
     self, BinOp, Block, CallableBody, CallableDecl, Expr, ExprKind, Functor, Lit, Mutability,
-    NodeId, PackageId, Pat, PatKind, PrimField, QubitInit, QubitInitKind, Res, Spec, SpecBody,
-    SpecGen, Stmt, StmtKind, StringComponent, TernOp, UnOp,
+    NodeId, PackageId, Pat, PatKind, PrimField, Res, Spec, SpecBody, SpecGen, Stmt, StmtKind,
+    StringComponent, TernOp, UnOp,
 };
 use std::{
     collections::{hash_map::Entry, HashMap},
@@ -35,7 +32,7 @@ use std::{
     rc::Rc,
 };
 use thiserror::Error;
-use val::{GlobalId, Qubit};
+use val::GlobalId;
 
 #[derive(Clone, Debug, Diagnostic, Error)]
 pub enum Error {
@@ -88,7 +85,7 @@ pub enum Error {
     RangeStepZero(#[label("invalid range")] Span),
 
     #[error("Qubit{0} released while not in |0⟩ state")]
-    ReleasedQubitNotZero(usize, #[label] Span),
+    ReleasedQubitNotZero(usize),
 
     #[error("mismatched types")]
     Type(
@@ -247,7 +244,6 @@ impl Env {
 #[derive(Default)]
 struct Scope {
     bindings: HashMap<NodeId, Variable>,
-    qubits: Vec<(Qubit, Span)>,
 }
 
 impl Env {
@@ -261,7 +257,6 @@ enum Event<'a> {
     Cont(Cont<'a>),
     Expr(&'a Expr),
     Frame,
-    Qubit(&'a QubitInit),
     Scope,
     Stmt(&'a Stmt),
 }
@@ -279,7 +274,6 @@ enum Cont<'a> {
     Field(PrimField, Span),
     If(&'a Block, &'a Option<Box<Expr>>),
     Index(Span),
-    QubitArray(Span, Span),
     Range(bool, bool, bool),
     Return,
     StringConcat(usize),
@@ -357,38 +351,16 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
         self.push_val(last_val);
     }
 
-    fn push_qubit(&mut self, qubit_init: &'a QubitInit) {
-        self.stack.push(Event::Qubit(qubit_init));
-    }
-
     fn push_scope(&mut self) {
         self.env.0.push(Scope::default());
         self.stack.push(Event::Scope);
     }
 
-    fn track_qubit(&mut self, qubit: Qubit, span: Span) {
+    fn leave_scope(&mut self) {
         self.env
-            .0
-            .last_mut()
-            .expect("scope should have been entered to track qubits")
-            .qubits
-            .push((qubit, span));
-    }
-
-    fn leave_scope(&mut self) -> Result<(), Error> {
-        for (qubit, span) in self
-            .env
             .0
             .pop()
-            .expect("scope should be entered first before leaving")
-            .qubits
-        {
-            if !qubit_is_zero(qubit.0) {
-                return Err(Error::ReleasedQubitNotZero(qubit.0 as usize, span));
-            }
-            __quantum__rt__qubit_release(qubit.0);
-        }
-        Ok(())
+            .expect("scope should be entered first before leaving");
     }
 
     fn push_stmt(&mut self, stmt: &'a Stmt) {
@@ -436,11 +408,10 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
                     self.leave_frame();
                     Ok(())
                 }
-                Event::Qubit(qubit_init) => {
-                    self.handle_qubit_init(qubit_init);
+                Event::Scope => {
+                    self.leave_scope();
                     Ok(())
                 }
-                Event::Scope => self.leave_scope(),
                 Event::Stmt(stmt) => {
                     self.handle_stmt(stmt);
                     Ok(())
@@ -698,14 +669,7 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
                 self.push_expr(expr);
                 self.push_val(Value::unit());
             }
-            StmtKind::Qubit(_, pat, qubit_init, block) => {
-                if let Some(block) = block {
-                    self.push_block(block);
-                }
-                self.push_cont(Cont::Bind(pat, Mutability::Immutable));
-                self.push_qubit(qubit_init);
-                self.push_val(Value::unit());
-            }
+            StmtKind::Qubit(..) => panic!("qubit use-stmt should be eliminated by passes"),
             StmtKind::Semi(expr) => {
                 self.push_cont(Cont::Consume);
                 self.push_expr(expr);
@@ -714,26 +678,6 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
         }
     }
 
-    fn handle_qubit_init(&mut self, qubit_init: &'a QubitInit) {
-        match &qubit_init.kind {
-            QubitInitKind::Array(count) => {
-                self.push_cont(Cont::QubitArray(qubit_init.span, count.span));
-                self.push_expr(count);
-            }
-            QubitInitKind::Single => {
-                let qubit = Qubit(__quantum__rt__qubit_allocate());
-                self.track_qubit(qubit, qubit_init.span);
-                self.push_val(Value::Qubit(qubit));
-            }
-            QubitInitKind::Tuple(tup) => {
-                self.push_cont(Cont::Tuple(tup.len()));
-                for init in tup.iter().rev() {
-                    self.push_qubit(init);
-                }
-            }
-        }
-    }
-
     fn cont(&mut self, cont: Cont<'a>) -> Result<(), Error> {
         match cont {
             Cont::Array(len) => self.cont_array(len),
@@ -754,13 +698,10 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
             Cont::Field(field, span) => self.cont_field(field, span)?,
             Cont::If(then_block, else_expr) => self.cont_if(then_block, else_expr),
             Cont::Index(span) => self.cont_index(span)?,
-            Cont::QubitArray(qubit_span, count_span) => {
-                self.cont_qubit_array(qubit_span, count_span)?;
-            }
             Cont::Range(has_start, has_step, has_end) => {
                 self.cont_range(has_start, has_step, has_end);
             }
-            Cont::Return => self.cont_ret()?,
+            Cont::Return => self.cont_ret(),
             Cont::StringConcat(len) => self.cont_string_concat(len),
             Cont::StringLit(str) => self.push_val(Value::String(Rc::clone(str))),
             Cont::TernOp(op, mid, rhs) => self.cont_ternop(op, mid, rhs)?,
@@ -947,22 +888,6 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
         Ok(())
     }
 
-    fn cont_qubit_array(&mut self, qubit_span: Span, count_span: Span) -> Result<(), Error> {
-        let count_val = self.pop_val().into_int();
-        let count: usize = match count_val.try_into() {
-            Ok(i) => Ok(i),
-            Err(_) => Err(Error::Count(count_val, count_span)),
-        }?;
-        let mut arr = Vec::new();
-        for _ in 0..count {
-            let qubit = Qubit(__quantum__rt__qubit_allocate());
-            self.track_qubit(qubit, qubit_span);
-            arr.push(Value::Qubit(qubit));
-        }
-        self.push_val(Value::Array(arr.into()));
-        Ok(())
-    }
-
     fn cont_range(&mut self, has_start: bool, has_step: bool, has_end: bool) {
         let end = if has_end {
             Some(self.pop_val().into_int())
@@ -982,7 +907,7 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
         self.push_val(Value::Range(start, step, end));
     }
 
-    fn cont_ret(&mut self) -> Result<(), Error> {
+    fn cont_ret(&mut self) {
         loop {
             let Some(event) = self.pop_event() else {
                 break;
@@ -992,13 +917,10 @@ impl<'a, G: GlobalLookup<'a>> State<'a, G> {
                     self.leave_frame();
                     break;
                 }
-                Event::Scope => {
-                    self.leave_scope()?;
-                }
+                Event::Scope => self.leave_scope(),
                 _ => {}
             }
         }
-        Ok(())
     }
 
     fn cont_string_concat(&mut self, len: usize) {

compiler/qsc_eval/src/tests.rs

@@ -6,15 +6,17 @@ use expect_test::{expect, Expect};
 use indoc::indoc;
 use qsc_frontend::compile::{self, compile, PackageStore, SourceMap};
 use qsc_hir::hir::{CallableDecl, ItemKind};
-use qsc_passes::run_default_passes;
+use qsc_passes::{run_core_passes, run_default_passes};
 
 fn check_expr(file: &str, expr: &str, expect: &Expect) {
-    let mut store = PackageStore::new(compile::core());
+    let mut core = compile::core();
+    run_core_passes(&mut core);
+    let mut store = PackageStore::new(core);
     let sources = SourceMap::new([("test".into(), file.into())], Some(expr.into()));
     let mut unit = compile(&store, &[], sources);
     assert!(unit.errors.is_empty(), "{:?}", unit.errors);
 
-    let pass_errors = run_default_passes(&mut unit);
+    let pass_errors = run_default_passes(&mut unit, &store);
     assert!(pass_errors.is_empty(), "{pass_errors:?}");
 
     let id = store.insert(unit);
@@ -313,15 +315,39 @@ fn block_qubit_use_array_invalid_count_expr() {
         }"},
         &expect![[r#"
             (
-                Count(
-                    -3,
+                UserFail(
+                    "Cannot allocate qubit array with a negative length",
                     Span {
-                        lo: 20,
-                        hi: 22,
+                        lo: 371,
+                        hi: 428,
                     },
                 ),
                 CallStack {
-                    frames: [],
+                    frames: [
+                        Frame {
+                            span: Some(
+                                Span {
+                                    lo: 10,
+                                    hi: 11,
+                                },
+                            ),
+                            id: GlobalId {
+                                package: PackageId(
+                                    0,
+                                ),
+                                item: LocalItemId(
+                                    3,
+                                ),
+                            },
+                            caller: PackageId(
+                                1,
+                            ),
+                            functor: FunctorApp {
+                                adjoint: false,
+                                controlled: 0,
+                            },
+                        },
+                    ],
                 },
             )
         "#]],