feat: Update quil-rs (#350)

* feat: Update quil-rs

* Update crates/python/src/qpu/rewrite_arithmetic.rs

Co-authored-by: Mark Skilbeck <[email protected]>

* un-swap error messages

---------

Co-authored-by: Mark Skilbeck <[email protected]>

Author: MarquessV

Cargo.lock

@@ -15,7 +15,7 @@ tokio = "1.24.2"
 # be a `quil-py` tag and should match the version used in `crates/python/pyproject.toml`
 # The version must also be specified in order to publish to crates.io. Cargo enforces
 # that the specified version is the same as the version in the git repository.
-quil-rs = { version = "0.20.0", git = "https://github.com/rigetti/quil-rs", tag = "quil-py/v0.4.0" }
+quil-rs = { version = "0.21.0", git = "https://github.com/rigetti/quil-rs", tag = "quil-py/v0.5.0" }
 
 # ndarray is used by the `qcs` crate, but it is also used in the `python` crate via a
 # re-export through the numpy crate. They should be updated as a pair to keep both

Cargo.toml

@@ -411,6 +411,7 @@ mod tests {
 
     use super::*;
     use qcs_api_client_openapi::models::InstructionSetArchitecture;
+    use quil_rs::quil::Quil;
     use regex::Regex;
     use std::{fs::File, num::NonZeroU16};
 
@@ -433,7 +434,7 @@ mod tests {
             CompilerOpts::default(),
         )
         .expect("Could not compile");
-        assert_eq!(output.program.to_string(), EXPECTED_H0_OUTPUT);
+        assert_eq!(output.program.to_quil_or_debug(), EXPECTED_H0_OUTPUT);
     }
 
     const BELL_STATE: &str = r##"DECLARE ro BIT[2]
@@ -455,7 +456,7 @@ MEASURE 1 ro[1]
             CompilerOpts::default(),
         )
         .expect("Could not compile");
-        let mut results = crate::qvm::Execution::new(&output.program.to_string())
+        let mut results = crate::qvm::Execution::new(&output.program.to_quil_or_debug())
             .unwrap()
             .run(
                 NonZeroU16::new(10).expect("value is non-zero"),
@@ -490,7 +491,7 @@ MEASURE 1 ro[1]
             CompilerOpts::default(),
         )
         .expect("Should be able to compile");
-        assert_eq!(output.program.to_string(), "DECLARE ro BIT[1]\n");
+        assert_eq!(output.program.to_quil_or_debug(), "DECLARE ro BIT[1]\n");
         assert_ne!(output.native_quil_metadata, None);
     }
 

crates/lib/src/compiler/quilc.rs

@@ -9,6 +9,7 @@ use std::time::Duration;
 
 use qcs_api_client_common::configuration::LoadError;
 use qcs_api_client_grpc::services::translation::TranslationOptions;
+use quil_rs::quil::ToQuilError;
 
 use crate::client::Qcs;
 use crate::compiler::quilc::CompilerOpts;
@@ -621,6 +622,9 @@ pub enum Error {
     /// some parameters.
     #[error("There was a problem with the Quil program: {0}")]
     Quil(#[from] ProgramError),
+    /// There was some problem converting the provided Quil program to valid Quil.
+    #[error("There was a problem converting the program to valid Quil: {0}")]
+    ToQuil(#[from] ToQuilError),
     /// There was a problem when compiling the Quil program.
     #[error("There was a problem compiling the Quil program: {0}")]
     Compilation(String),
@@ -687,6 +691,7 @@ impl From<ExecutionError> for Error {
             ExecutionError::IsaError(v) => Self::Unexpected(format!("{v:?}")),
             ExecutionError::ReadoutParse(v) => Self::Unexpected(format!("{v:?}")),
             ExecutionError::Quil(e) => Self::Quil(e),
+            ExecutionError::ToQuil(e) => Self::ToQuil(e),
             ExecutionError::Compilation { details } => Self::Compilation(details),
             ExecutionError::RewriteArithmetic(e) => Self::RewriteArithmetic(e),
             ExecutionError::Substitution(message) => Self::Substitution(message),
@@ -701,6 +706,7 @@ impl From<qvm::Error> for Error {
             qvm::Error::QvmCommunication { .. } | qvm::Error::Client { .. } => {
                 Self::Connection(Service::Qvm)
             }
+            qvm::Error::ToQuil(q) => Self::ToQuil(q),
             qvm::Error::Parsing(_)
             | qvm::Error::ShotsMustBePositive
             | qvm::Error::RegionSizeMismatch { .. }

crates/lib/src/executable.rs

@@ -8,6 +8,7 @@ use std::time::Duration;
 
 use qcs_api_client_grpc::services::translation::TranslationOptions;
 use quil_rs::program::ProgramError;
+use quil_rs::quil::ToQuilError;
 use tokio::task::{spawn_blocking, JoinError};
 
 #[cfg(feature = "tracing")]
@@ -43,6 +44,8 @@ pub(crate) struct Execution<'a> {
 pub(crate) enum Error {
     #[error("problem processing the provided Quil: {0}")]
     Quil(#[from] ProgramError),
+    #[error("problem converting the program to valid Quil: {0}")]
+    ToQuil(#[from] ToQuilError),
     #[error("An error that is not expected to occur. If this shows up it may be a bug in this SDK or QCS")]
     Unexpected(#[from] Unexpected),
     #[error("Problem communicating with quilc at {uri}: {details}")]
@@ -176,7 +179,7 @@ impl<'a> Execution<'a> {
     ) -> Result<EncryptedTranslationResult, Error> {
         let encrpyted_translation_result = translate(
             self.quantum_processor_id.as_ref(),
-            &self.program.to_string().0,
+            &self.program.to_string()?.0,
             self.shots.get().into(),
             self.client.as_ref(),
             options,

crates/lib/src/qpu/execution.rs

@@ -12,6 +12,7 @@ use quil_rs::{
         SetFrequency, SetPhase, SetScale, ShiftFrequency, ShiftPhase, Vector,
     },
     program::{FrameSet, MemoryRegion},
+    quil::{Quil, ToQuilError},
     Program,
 };
 
@@ -125,7 +126,12 @@ pub fn get_substitutions(
         .map(|substitution: &Expression| {
             substitution
                 .evaluate(&HashMap::new(), &params)
-                .map_err(|e| format!("Could not evaluate expression {substitution}: {e:?}"))
+                .map_err(|e| {
+                    format!(
+                        "Could not evaluate expression {}: {e:?}",
+                        substitution.to_quil_or_debug()
+                    )
+                })
                 .and_then(|complex| {
                     if complex.im == 0.0 {
                         Ok(complex.re)
@@ -356,16 +362,16 @@ impl TryFrom<Program> for RewrittenProgram {
 }
 
 impl RewrittenProgram {
-    pub(crate) fn to_string(&self) -> RewrittenQuil {
-        RewrittenQuil(self.inner.to_string())
+    pub(crate) fn to_string(&self) -> Result<RewrittenQuil, ToQuilError> {
+        Ok(RewrittenQuil(self.inner.to_quil()?))
     }
 }
 
 #[cfg(test)]
 mod describe_rewrite_arithmetic {
     use std::str::FromStr;
 
-    use quil_rs::Program;
+    use quil_rs::{quil::Quil, Program};
 
     use crate::qpu::rewrite_arithmetic::rewrite_arithmetic;
 
@@ -378,7 +384,7 @@ mod describe_rewrite_arithmetic {
         let (actual, substitutions) = rewrite_arithmetic(program).unwrap();
         assert_eq!(actual, expected);
         assert_eq!(substitutions.len(), 1);
-        insta::assert_snapshot!(substitutions[0].to_string());
+        insta::assert_snapshot!(substitutions[0].to_quil_or_debug());
     }
 
     #[test]
@@ -400,7 +406,7 @@ mod describe_rewrite_arithmetic {
         let (actual, substitutions) = rewrite_arithmetic(program).unwrap();
         assert_eq!(actual, expected);
         assert_eq!(substitutions.len(), 1);
-        insta::assert_snapshot!(substitutions[0].to_string());
+        insta::assert_snapshot!(substitutions[0].to_quil_or_debug());
     }
 
     #[test]
@@ -427,8 +433,8 @@ RZ(__SUBST[1]) 0
         let (actual, substitutions) = rewrite_arithmetic(program).unwrap();
         assert_eq!(actual, expected);
         assert_eq!(substitutions.len(), 2);
-        insta::assert_snapshot!(substitutions[0].to_string());
-        insta::assert_snapshot!(substitutions[1].to_string());
+        insta::assert_snapshot!(substitutions[0].to_quil_or_debug());
+        insta::assert_snapshot!(substitutions[1].to_quil_or_debug());
     }
 
     #[test]
@@ -453,7 +459,7 @@ SET-SCALE 0 "rf" __SUBST[0]
         let (actual, substitutions) = rewrite_arithmetic(program).unwrap();
         assert_eq!(actual, expected);
         assert_eq!(substitutions.len(), 1);
-        insta::assert_snapshot!(substitutions[0].to_string());
+        insta::assert_snapshot!(substitutions[0].to_quil_or_debug());
     }
 
     #[test]
@@ -490,8 +496,8 @@ SET-FREQUENCY 1 "rf" __SUBST[1]
         let (actual, substitutions) = rewrite_arithmetic(program).unwrap();
         assert_eq!(actual, expected);
         assert_eq!(substitutions.len(), 2);
-        insta::assert_snapshot!(substitutions[0].to_string());
-        insta::assert_snapshot!(substitutions[1].to_string());
+        insta::assert_snapshot!(substitutions[0].to_quil_or_debug());
+        insta::assert_snapshot!(substitutions[1].to_quil_or_debug());
     }
 
     #[test]
@@ -550,7 +556,7 @@ SHIFT-PHASE 0 "rf" __SUBST[0]
         let (actual, substitutions) = rewrite_arithmetic(program).unwrap();
         assert_eq!(actual, expected);
         assert_eq!(substitutions.len(), 1);
-        insta::assert_snapshot!(substitutions[0].to_string());
+        insta::assert_snapshot!(substitutions[0].to_quil_or_debug());
     }
 }
 

crates/lib/src/qpu/rewrite_arithmetic.rs

@@ -6,6 +6,7 @@ use std::{collections::HashMap, num::NonZeroU16, str::FromStr, time::Duration};
 use quil_rs::{
     instruction::{ArithmeticOperand, Instruction, MemoryReference, Move},
     program::ProgramError,
+    quil::{Quil, ToQuilError},
     Program,
 };
 use serde::Deserialize;
@@ -97,7 +98,7 @@ pub async fn run_program(
     );
     let program = apply_parameters_to_program(program, params)?;
     let request = api::MultishotRequest::new(
-        program.to_string(),
+        program.to_quil()?,
         shots,
         addresses,
         measurement_noise,
@@ -188,6 +189,8 @@ impl Default for QvmOptions {
 pub enum Error {
     #[error("Error parsing Quil program: {0}")]
     Parsing(#[from] ProgramError),
+    #[error("Error converting program to valid Quil: {0}")]
+    ToQuil(#[from] ToQuilError),
     #[error("Shots must be a positive integer.")]
     ShotsMustBePositive,
     #[error("Declared region {name} has size {declared} but parameters have size {parameters}.")]
@@ -213,7 +216,7 @@ pub enum Error {
 mod test {
     use std::{collections::HashMap, str::FromStr};
 
-    use quil_rs::Program;
+    use quil_rs::{quil::Quil, Program};
     use rstest::{fixture, rstest};
 
     use super::apply_parameters_to_program;
@@ -237,7 +240,7 @@ mod test {
         let parameterized_program = apply_parameters_to_program(&program, &params)
             .expect("should not error for empty parameters");
 
-        insta::assert_snapshot!(parameterized_program.to_string());
+        insta::assert_snapshot!(parameterized_program.to_quil_or_debug());
     }
 
     #[rstest]

crates/lib/src/qvm/mod.rs

@@ -20,7 +20,7 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Operating System :: OS Independent",
 ]
-dependencies = ["quil==0.4.0"]
+dependencies = ["quil==0.5.0"]
 
 # PEP 621 specifies the [project] table as the source for project metadata. However, Poetry only supports [tool.poetry]
 # We can remove this table once this issue is resolved: https://github.com/python-poetry/poetry/issues/3332

crates/python/pyproject.toml

@@ -4,6 +4,7 @@ use qcs::compiler::quilc::{
     RandomizedBenchmarkingRequest, TargetDevice, DEFAULT_COMPILER_TIMEOUT,
 };
 use qcs_api_client_openapi::models::InstructionSetArchitecture;
+use quil_rs::quil::Quil;
 use rigetti_pyo3::{
     create_init_submodule, impl_repr, py_wrap_data_struct, py_wrap_error, py_wrap_struct,
     py_wrap_type,
@@ -113,7 +114,7 @@ py_function_sync_async! {
             .map_err(RustQuilcError::from)
             .map_err(RustQuilcError::to_py_err)
             .map(|result| PyCompilationResult {
-                program: result.program.to_string(),
+                program: result.program.to_quil().expect("successfully compiled program should convert to valid quil"),
                 native_quil_metadata: result.native_quil_metadata.map(PyNativeQuilMetadata)
             })
 

crates/python/src/compiler/quilc.rs

@@ -2,7 +2,7 @@
 use std::{collections::HashMap, str::FromStr};
 
 use pyo3::{exceptions::PyRuntimeError, pyclass, pyfunction, PyResult};
-use quil_rs::expression::Expression;
+use quil_rs::{expression::Expression, quil::Quil};
 use rigetti_pyo3::{create_init_submodule, py_wrap_error, ToPythonError};
 
 create_init_submodule! {
@@ -74,8 +74,17 @@ pub fn rewrite_arithmetic(native_quil: String) -> PyResult<PyRewriteArithmeticRe
         .map_err(RustRewriteArithmeticError::from)
         .map_err(RustRewriteArithmeticError::to_py_err)?;
 
-    let program = program.to_string();
-    let recalculation_table = index_set.into_iter().map(|e| e.to_string()).collect();
+    let program = program
+        .to_quil()
+        .expect("Successfully parsed program should convert to valid Quil.");
+    let recalculation_table = index_set
+        .into_iter()
+        .map(|e| {
+            e.to_quil().expect(
+                "Expressions built from a successfully parsed program should convert to valid Quil.",
+            )
+        })
+        .collect();
 
     Ok(PyRewriteArithmeticResult {
         program,