Use rust-native error for ConsolidateBlocks

The following commits modify `ConsolidateBlocks` to use rust-native errors throughout its pipeline.
We implement the `ConsolidateBlocksError` enumeration which derives from `DAGCircuitError`, and `CircuitDataError`, as well as adding two new variants for python specific errors dealing with matrices and controlled u gates.

Author: raynelfss

crates/transpiler/src/passes/consolidate_blocks.rs

@@ -21,8 +21,8 @@ use pyo3::exceptions::PyIndexError;
 use pyo3::intern;
 use pyo3::prelude::*;
 use qiskit_circuit::Qubit;
-use qiskit_circuit::circuit_data::CircuitData;
-use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType};
+use qiskit_circuit::circuit_data::{CircuitData, CircuitDataError};
+use qiskit_circuit::dag_circuit::{DAGCircuit, DAGCircuitInnerError, NodeType};
 use qiskit_circuit::gate_matrix::{
     CH_GATE, CX_GATE, CY_GATE, CZ_GATE, DCX_GATE, ECR_GATE, ISWAP_GATE, ONE_QUBIT_IDENTITY,
 };
@@ -46,6 +46,39 @@ use crate::passes::unitary_synthesis::{PARAM_SET, TWO_QUBIT_BASIS_SET};
 use crate::target::{Qargs, Target};
 use qiskit_circuit::PhysicalQubit;
 
+/// Possible errors coming from the `ConsolidateBlocks` pass.
+#[derive(Debug, thiserror::Error)]
+pub enum ConsolidateBlocksError {
+    #[error("node index in run or block was not a valid operation")]
+    InvalidIndexOp,
+    #[error(transparent)]
+    DAGCircuit(#[from] DAGCircuitInnerError),
+    #[error(transparent)]
+    Circuit(#[from] CircuitDataError),
+    #[error(transparent)]
+    // TODO: Replace with decomposer rust native error
+    PyTwoQubitBasisDecomposer(PyErr),
+    #[error(transparent)]
+    PyMatrixError(PyErr),
+    #[error(transparent)]
+    PyTwoQubitControlledU(PyErr),
+}
+
+impl From<ConsolidateBlocksError> for PyErr {
+    fn from(value: ConsolidateBlocksError) -> Self {
+        match value {
+            ConsolidateBlocksError::DAGCircuit(dagcircuit_inner_error) => {
+                dagcircuit_inner_error.into()
+            }
+            ConsolidateBlocksError::Circuit(circuit_data_error) => circuit_data_error.into(),
+            ConsolidateBlocksError::InvalidIndexOp => PyIndexError::new_err(value.to_string()),
+            ConsolidateBlocksError::PyMatrixError(py_err)
+            | ConsolidateBlocksError::PyTwoQubitBasisDecomposer(py_err)
+            | ConsolidateBlocksError::PyTwoQubitControlledU(py_err) => py_err,
+        }
+    }
+}
+
 static IDENTITY_2Q: Matrix4<Complex64> = Matrix4::new(
     // Row 1
     Complex64::ONE,
@@ -232,6 +265,32 @@ fn py_run_consolidate_blocks(
     runs: Option<Vec<Vec<usize>>>,
     qubit_map: Option<Vec<PhysicalQubit>>,
 ) -> PyResult<()> {
+    inner_run_consolidate_blocks(
+        dag,
+        decomposer,
+        basis_gate_name,
+        force_consolidate,
+        target,
+        basis_gates,
+        blocks,
+        runs,
+        qubit_map,
+    )
+    .map_err(Into::into)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn inner_run_consolidate_blocks(
+    dag: &mut DAGCircuit,
+    decomposer: Option<DecomposerType>,
+    basis_gate_name: &str,
+    force_consolidate: bool,
+    target: Option<&Target>,
+    basis_gates: Option<HashSet<String>>,
+    blocks: Option<Vec<Vec<usize>>>,
+    runs: Option<Vec<Vec<usize>>>,
+    qubit_map: Option<Vec<PhysicalQubit>>,
+) -> Result<(), ConsolidateBlocksError> {
     // If we don't have a decomposer and force consolidate is not set then there is not any
     // consolidation to do.
     if decomposer.is_none() && !force_consolidate {
@@ -241,15 +300,14 @@ fn py_run_consolidate_blocks(
     // trust that they come from a correct analysis (or the block/run collection might have been
     // invalidated). Rather than panicking, we should raise Python-space exceptions. We don't have
     // to check indices that are generated by trusted Rust-only methods within this function.
-    let valid_op_node = |dag: &mut DAGCircuit, index: usize| -> PyResult<NodeIndex> {
-        let index = NodeIndex::new(index);
-        match dag.dag().node_weight(index) {
-            Some(NodeType::Operation(_)) => Ok(index),
-            _ => Err(PyIndexError::new_err(
-                "node index in run or block was not a valid operation",
-            )),
-        }
-    };
+    let valid_op_node =
+        |dag: &mut DAGCircuit, index: usize| -> Result<NodeIndex, ConsolidateBlocksError> {
+            let index = NodeIndex::new(index);
+            match dag.dag().node_weight(index) {
+                Some(NodeType::Operation(_)) => Ok(index),
+                _ => Err(ConsolidateBlocksError::InvalidIndexOp),
+            }
+        };
     let blocks = match blocks {
         Some(runs) => runs
             .into_iter()
@@ -385,7 +443,8 @@ fn py_run_consolidate_blocks(
                     .as_array()
                     .to_owned();
                 Ok(matrix)
-            })?;
+            })
+            .map_err(ConsolidateBlocksError::PyMatrixError)?;
             let identity: Array2<Complex64> = Array2::eye(2usize.pow(block_qargs.len() as u32));
             if approx::abs_diff_eq!(identity, matrix.view()) {
                 for node in block {
@@ -422,19 +481,19 @@ fn py_run_consolidate_blocks(
                 } else {
                     let num_basis_gates = if let Some(ref decomposer) = decomposer {
                         match decomposer {
-                            DecomposerType::TwoQubitBasis(decomp) => {
-                                decomp.num_basis_gates_inner(nalgebra_array_view::<
-                                    Complex64,
-                                    U4,
-                                    U4,
-                                >(
-                                    matrix.as_view()
-                                ))?
-                            }
+                            DecomposerType::TwoQubitBasis(decomp) => decomp
+                                .num_basis_gates_inner(nalgebra_array_view::<Complex64, U4, U4>(
+                                    matrix.as_view(),
+                                ))
+                                .map_err(ConsolidateBlocksError::PyTwoQubitBasisDecomposer)?,
                             DecomposerType::TwoQubitControlledU(decomp) => decomp
                                 .num_basis_gates_inner(nalgebra_array_view::<Complex64, U4, U4>(
                                     matrix.as_view(),
-                                ))?,
+                                ))
+                                // The only way this throws an error is if it deals with a
+                                // bad Python operation. So we can just wrap it into its own
+                                // special case.
+                                .map_err(ConsolidateBlocksError::PyTwoQubitControlledU)?,
                         }
                     } else {
                         unreachable!("A decomposer is always set unless force_consolidate is true");
@@ -576,10 +635,10 @@ pub fn run_consolidate_blocks(
     force_consolidate: bool,
     approximation_degree: Option<f64>,
     target: Option<&Target>,
-) -> PyResult<()> {
+) -> Result<(), ConsolidateBlocksError> {
     let approximation_degree = approximation_degree.unwrap_or(1.0);
     if force_consolidate {
-        py_run_consolidate_blocks(
+        inner_run_consolidate_blocks(
             dag,
             None,
             "cx",
@@ -593,7 +652,7 @@ pub fn run_consolidate_blocks(
         )
     } else {
         let (decomposer, basis_gate) = get_decomposer_and_basis_gate(target, approximation_degree);
-        py_run_consolidate_blocks(
+        inner_run_consolidate_blocks(
             dag,
             Some(decomposer),
             basis_gate.name(),