From 08c8f8e3d49550edb24b9b66b15e823283894e9a Mon Sep 17 00:00:00 2001 From: "Stefan J. Wernli" Date: Sat, 30 May 2026 16:38:29 -0700 Subject: [PATCH 1/4] RIFLA: Support emitting constant `Result` arrays This change supports the emission of constant `Result` arrays for Adaptive RIFLA QIR generation. To do so, we needed the compiler to see arrays of result values as "dynamic constant" expressions, which required a change to how `Result` values are handled during RCA and Partial Eval. Previously, any `Result` value coming back from an intrinsic operation was treated a dynamic variable, even though they are really just identifiers. This updates that logic to recognized results as identifiers, the same way qubits are identifiers, and moves the source of dynamic variables in RCA to the actual comparison of results rather than being inherent to the result itself. To make sure this quality propagates across function call boundaries appropriately, RCA was updated to differentiate between call arguments that are static vs dynamic constant vs dynamic variable, where previously it only checked for dynamic variable and treated constant and static as the same. In addition, this also includes an update to RCA that adds a new capability to recognize when a static `Result` value (`One` or `Zero`) is used as the output from a dynamic expression, since that cannot be emitted into QIR. The new check detects this at analysis time so the error is visible in the editor before the user tries to emit QIR (if applicable). --- source/compiler/qsc_eval/src/val.rs | 2 + .../src/evaluation_context.rs | 63 +- source/compiler/qsc_partial_eval/src/lib.rs | 237 ++- source/compiler/qsc_partial_eval/src/tests.rs | 2 +- .../qsc_partial_eval/src/tests/bindings.rs | 3 +- .../qsc_partial_eval/src/tests/branching.rs | 22 - .../qsc_partial_eval/src/tests/loops.rs | 112 + .../qsc_partial_eval/src/tests/misc.rs | 13 +- .../compiler/qsc_passes/src/capabilitiesck.rs | 3 + .../src/capabilitiesck/tests_adaptive.rs | 25 + .../tests_adaptive_plus_integers.rs | 39 +- ...tests_adaptive_plus_integers_and_floats.rs | 43 +- ...tive_plus_integers_and_floats_and_loops.rs | 592 ++++++ .../src/capabilitiesck/tests_base.rs | 25 + .../src/capabilitiesck/tests_common.rs | 12 + source/compiler/qsc_rca/src/applications.rs | 118 +- source/compiler/qsc_rca/src/core.rs | 120 +- .../compiler/qsc_rca/src/cyclic_callables.rs | 26 +- source/compiler/qsc_rca/src/errors.rs | 11 + source/compiler/qsc_rca/src/lib.rs | 44 +- source/compiler/qsc_rca/src/overrider.rs | 1 + source/compiler/qsc_rca/src/tests.rs | 2 + source/compiler/qsc_rca/src/tests/arrays.rs | 8 +- source/compiler/qsc_rca/src/tests/assigns.rs | 16 +- source/compiler/qsc_rca/src/tests/bindings.rs | 2 +- .../compiler/qsc_rca/src/tests/callables.rs | 1860 ++++++++++++----- source/compiler/qsc_rca/src/tests/cycles.rs | 406 ++-- source/compiler/qsc_rca/src/tests/ifs.rs | 50 + .../compiler/qsc_rca/src/tests/intrinsics.rs | 583 ++++-- source/compiler/qsc_rca/src/tests/lambdas.rs | 2 +- .../qsc_rca/src/tests/measurements.rs | 6 +- source/compiler/qsc_rca/src/tests/strings.rs | 6 +- source/compiler/qsc_rca/src/tests/types.rs | 2 +- source/compiler/qsc_rca/src/tests/vars.rs | 2 +- .../adaptive_rifla/output/ArithmeticOps.ll | 165 +- .../adaptive_rifla/output/SwitchHandling.ll | 114 +- 36 files changed, 3474 insertions(+), 1263 deletions(-) create mode 100644 source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers_and_floats_and_loops.rs diff --git a/source/compiler/qsc_eval/src/val.rs b/source/compiler/qsc_eval/src/val.rs index b1c392d2a8..3891e45aa8 100644 --- a/source/compiler/qsc_eval/src/val.rs +++ b/source/compiler/qsc_eval/src/val.rs @@ -237,6 +237,7 @@ pub enum VarTy { Integer, Double, Qubit, + Result, } impl Display for VarTy { @@ -246,6 +247,7 @@ impl Display for VarTy { Self::Integer => write!(f, "Integer"), Self::Double => write!(f, "Double"), Self::Qubit => write!(f, "Qubit"), + Self::Result => write!(f, "Result"), } } } diff --git a/source/compiler/qsc_partial_eval/src/evaluation_context.rs b/source/compiler/qsc_partial_eval/src/evaluation_context.rs index 02e8e5e06d..4b2755b1f1 100644 --- a/source/compiler/qsc_partial_eval/src/evaluation_context.rs +++ b/source/compiler/qsc_partial_eval/src/evaluation_context.rs @@ -144,10 +144,8 @@ impl Scope { Arg::Discard(value) => value, Arg::Var(_, var) => &var.value, }; - ComputeKind::Dynamic { - runtime_features: RuntimeFeatureFlags::empty(), - value_kind: map_eval_value_to_value_kind(value), - } + + map_eval_value_to_compute_kind(value) }) .collect(); @@ -296,28 +294,60 @@ impl EvalControlFlow { } } -fn map_eval_value_to_value_kind(value: &Value) -> ValueKind { +fn map_eval_value_to_compute_kind(value: &Value) -> ComputeKind { match value { Value::Array(elements) => { + let mut dynamic_count = 0; for element in elements.iter() { - let element_runtime_kind = map_eval_value_to_value_kind(element); - if element_runtime_kind == ValueKind::Variable { - return ValueKind::Variable; + let element_compute_kind = map_eval_value_to_compute_kind(element); + if let ComputeKind::Dynamic { value_kind, .. } = element_compute_kind { + if value_kind == ValueKind::Variable { + // A dynamic variable in an array makes the whole array dynamic and variable. + return element_compute_kind; + } + dynamic_count += 1; } } - - ValueKind::Constant + if dynamic_count > 0 { + // If there are any dynamic constant elements, the array is dynamic and constant. + ComputeKind::Dynamic { + runtime_features: RuntimeFeatureFlags::empty(), + value_kind: ValueKind::Constant, + } + } else { + ComputeKind::Static + } } Value::Tuple(elements, _) => { + let mut dynamic_count = 0; for element in elements.iter() { - let element_runtime_kind = map_eval_value_to_value_kind(element); - if element_runtime_kind == ValueKind::Variable { - return ValueKind::Variable; + let element_compute_kind = map_eval_value_to_compute_kind(element); + if let ComputeKind::Dynamic { value_kind, .. } = element_compute_kind { + if value_kind == ValueKind::Variable { + // A dynamic variable in a tuple makes the whole tuple dynamic and variable. + return element_compute_kind; + } + dynamic_count += 1; + } + } + if dynamic_count > 0 { + // If there are any dynamic constant elements, the tuple is dynamic and constant. + ComputeKind::Dynamic { + runtime_features: RuntimeFeatureFlags::empty(), + value_kind: ValueKind::Constant, } + } else { + ComputeKind::Static } - ValueKind::Constant } - Value::Result(Result::Id(_) | Result::Loss) | Value::Var(_) => ValueKind::Variable, + Value::Result(Result::Loss) | Value::Var(_) => ComputeKind::Dynamic { + runtime_features: RuntimeFeatureFlags::empty(), + value_kind: ValueKind::Variable, + }, + Value::Qubit(_) | Value::Result(Result::Id(_)) => ComputeKind::Dynamic { + runtime_features: RuntimeFeatureFlags::empty(), + value_kind: ValueKind::Constant, + }, Value::BigInt(_) | Value::Bool(_) | Value::Closure(_) @@ -325,9 +355,8 @@ fn map_eval_value_to_value_kind(value: &Value) -> ValueKind { | Value::Global(_, _) | Value::Int(_) | Value::Pauli(_) - | Value::Qubit(_) | Value::Range(_) | Value::Result(Result::Val(_)) - | Value::String(_) => ValueKind::Constant, + | Value::String(_) => ComputeKind::Static, } } diff --git a/source/compiler/qsc_partial_eval/src/lib.rs b/source/compiler/qsc_partial_eval/src/lib.rs index b71ce650c3..e2c328bb9f 100644 --- a/source/compiler/qsc_partial_eval/src/lib.rs +++ b/source/compiler/qsc_partial_eval/src/lib.rs @@ -604,9 +604,15 @@ impl<'a> PartialEvaluator<'a> { rhs_expr_id, bin_op_expr_span, ), - Value::Result(lhs_result) => self.eval_bin_op_with_lhs_result_operand( + Value::Result(_) => self.eval_bin_op_with_lhs_result_operand( bin_op, - lhs_result, + &lhs_value, + rhs_expr_id, + bin_op_expr_span, + ), + Value::Var(v) if v.ty == VarTy::Result => self.eval_bin_op_with_lhs_result_operand( + bin_op, + &lhs_value, rhs_expr_id, bin_op_expr_span, ), @@ -646,6 +652,33 @@ impl<'a> PartialEvaluator<'a> { }; Ok(EvalControlFlow::Continue(rhs_value)) } + Value::Pauli(p) => { + let rhs_control_flow = self.try_eval_expr(rhs_expr_id)?; + let EvalControlFlow::Continue(rhs_value) = rhs_control_flow else { + return Err(Error::Unexpected( + "embedded return in RHS expression".to_string(), + self.get_expr_package_span(rhs_expr_id), + )); + }; + match bin_op { + BinOp::Eq => { + let Value::Pauli(rhs_pauli) = rhs_value else { + panic!("expected pauli value from RHS expression"); + }; + Ok(EvalControlFlow::Continue(Value::Bool(p == rhs_pauli))) + } + BinOp::Neq => { + let Value::Pauli(rhs_pauli) = rhs_value else { + panic!("expected pauli value from RHS expression"); + }; + Ok(EvalControlFlow::Continue(Value::Bool(p != rhs_pauli))) + } + _ => Err(Error::Unimplemented( + "pauli binary operation".to_string(), + bin_op_expr_span, + )), + } + } _ => Err(Error::Unexpected( format!("unsupported LHS value: {lhs_value}"), lhs_span, @@ -696,7 +729,7 @@ impl<'a> PartialEvaluator<'a> { fn eval_bin_op_with_lhs_result_operand( &mut self, bin_op: BinOp, - lhs_result: val::Result, + lhs_value: &Value, rhs_expr_id: ExprId, bin_op_expr_span: PackageSpan, // For diagnostic purposes only. ) -> Result { @@ -707,9 +740,6 @@ impl<'a> PartialEvaluator<'a> { self.get_expr_package_span(rhs_expr_id), )); }; - let Value::Result(rhs_result) = rhs_value else { - panic!("expected result value from RHS expression"); - }; // Even though to get to this path, an expression would have to be categorized as hybrid by RCA, it is // possible that the expression is in fact purely classical. @@ -717,8 +747,10 @@ impl<'a> PartialEvaluator<'a> { // dynamic values. In such instances, RCA identifies all the contents of the data structure as dynamic even if // some values are static. // Here we handle this case and if both operands are purely classical we evaluate them. - if let (val::Result::Val(lhs_result_value), val::Result::Val(rhs_result_value)) = - (lhs_result, rhs_result) + if let ( + Value::Result(val::Result::Val(lhs_result_value)), + Value::Result(val::Result::Val(rhs_result_value)), + ) = (lhs_value, &rhs_value) { let bool_value = match bin_op { BinOp::Eq => lhs_result_value == rhs_result_value, @@ -734,8 +766,8 @@ impl<'a> PartialEvaluator<'a> { } // Get the operands to use when generating the binary operation instruction. - let lhs_operand = self.eval_result_as_bool_operand(lhs_result); - let rhs_operand = self.eval_result_as_bool_operand(rhs_result); + let lhs_operand = self.eval_result_as_bool_operand(lhs_value); + let rhs_operand = self.eval_result_as_bool_operand(&rhs_value); // Create a variable to store the result of the expression. let variable_id = self.resource_manager.next_var(); @@ -1155,7 +1187,7 @@ impl<'a> PartialEvaluator<'a> { bin_op_expr_span, ) } - VarTy::Qubit => Err(Error::Unexpected( + VarTy::Qubit | VarTy::Result => Err(Error::Unexpected( format!( "unsupported LHS variable type {} in binary operation", lhs_eval_var.ty @@ -1822,14 +1854,7 @@ impl<'a> PartialEvaluator<'a> { callee_expr_span, )) } - "IntAsDouble" => { - let variable_id = self.resource_manager.next_var(); - self.convert_value(&args_value, rir::Variable::new_double(variable_id)) - } - "Truncate" => { - let variable_id = self.resource_manager.next_var(); - self.convert_value(&args_value, rir::Variable::new_integer(variable_id)) - } + "IntAsDouble" | "Truncate" => self.convert_value(&args_value, args_span), _ => self.eval_expr_call_to_intrinsic_qis( store_item_id, callable_decl, @@ -1887,8 +1912,11 @@ impl<'a> PartialEvaluator<'a> { let ret_val = match output_var { None => Value::unit(), Some(output_var) => { - if output_var.ty == rir::Ty::Prim(rir::Prim::Qubit) { - // We don't actually accept custom intrinsics that return qubits, so emit an error here. + if matches!( + output_var.ty, + rir::Ty::Prim(rir::Prim::Qubit | rir::Prim::Result) + ) { + // We don't actually accept custom intrinsics that return qubits or results, so emit an error here. return Err(Error::UnsupportedCustomIntrinsicType( callable_decl.output.to_string(), callee_expr_span, @@ -2246,14 +2274,6 @@ impl<'a> PartialEvaluator<'a> { )); }; - // Get the variable type corresponding to the value the unary operator acts upon. - let Some(eval_variable_type) = try_get_eval_var_type(&value) else { - return Err(Error::Unexpected( - format!("invalid type for unary operation value: {value}"), - value_expr_package_span, - )); - }; - // The leading positive operator is a no-op. if matches!(un_op, UnOp::Pos) { let control_flow = EvalControlFlow::Continue(value); @@ -2269,6 +2289,14 @@ impl<'a> PartialEvaluator<'a> { // For all the other supported unary operations we have to generate an instruction, so create a variable to // store the result. let variable_id = self.resource_manager.next_var(); + + // Get the variable type corresponding to the value the unary operator acts upon. + let Some(eval_variable_type) = try_get_eval_var_type(&value) else { + return Err(Error::Unexpected( + format!("invalid type for unary operation value: {value}"), + value_expr_package_span, + )); + }; let rir_variable_type = map_eval_var_type_to_rir_type(eval_variable_type); let rir_variable = rir::Variable { variable_id, @@ -2370,7 +2398,7 @@ impl<'a> PartialEvaluator<'a> { .capabilities .contains(TargetCapabilityFlags::BackwardsBranching)) { - map_rir_literal_to_eval_value(*literal) + map_rir_literal_to_eval_value(*literal, var.ty) } else { bound_value.clone() } @@ -2538,36 +2566,43 @@ impl<'a> PartialEvaluator<'a> { Ok(EvalControlFlow::Continue(Value::unit())) } - fn eval_result_as_bool_operand(&mut self, result: val::Result) -> Operand { - match result { - val::Result::Id(id) => { - // If this is a result ID, generate the instruction to read it. - let result_operand = Operand::Literal(Literal::Result( - id.try_into().expect("could not convert result ID to u32"), - )); - let read_result_callable_id = - self.get_or_insert_callable(builder::read_result_decl()); - let variable_id = self.resource_manager.next_var(); - let variable_ty = rir::Ty::Prim(rir::Prim::Boolean); - let variable = rir::Variable { - variable_id, - ty: variable_ty, - }; - // Current debug location should be set to the call expression currently being evaluated. - let metadata = self.metadata_from_current_dbg_location(); - let current_block = self.get_current_rir_block_mut(); - let instruction = Instruction::Call( - read_result_callable_id, - vec![result_operand], - Some(variable), - metadata, - ); - current_block.0.push(instruction); - Operand::Variable(variable) + fn eval_result_as_bool_operand(&mut self, result: &Value) -> Operand { + let result_operand = match result { + Value::Result(val::Result::Id(id)) => Operand::Literal(Literal::Result( + (*id) + .try_into() + .expect("could not convert result ID to u32"), + )), + Value::Var(v) if v.ty == VarTy::Result => { + Operand::Variable(map_eval_var_to_rir_var(*v)) } - val::Result::Val(bool) => Operand::Literal(Literal::Bool(bool)), - val::Result::Loss => panic!("loss result should not occur in partial evaluation"), - } + Value::Result(val::Result::Val(bool)) => return Operand::Literal(Literal::Bool(*bool)), + Value::Result(val::Result::Loss) => { + panic!("loss result should not occur in partial evaluation") + } + _ => unreachable!( + "result eval value should be result id or result variable, found: {result:?}" + ), + }; + // Generate the instruction to read the result. + let read_result_callable_id = self.get_or_insert_callable(builder::read_result_decl()); + let variable_id = self.resource_manager.next_var(); + let variable_ty = rir::Ty::Prim(rir::Prim::Boolean); + let variable = rir::Variable { + variable_id, + ty: variable_ty, + }; + // Current debug location should be set to the call expression currently being evaluated. + let metadata = self.metadata_from_current_dbg_location(); + let current_block = self.get_current_rir_block_mut(); + let instruction = Instruction::Call( + read_result_callable_id, + vec![result_operand], + Some(variable), + metadata, + ); + current_block.0.push(instruction); + Operand::Variable(variable) } fn generate_instructions_for_binary_operation_with_double_operands( @@ -2975,6 +3010,12 @@ impl<'a> PartialEvaluator<'a> { // Check if we can create a mutable variable for this value. let var_ty = try_get_eval_var_type(value)?; + // If the value is a result literal, we skip creating a mutable variable as these are not + // representable in QIR. + if var_ty == VarTy::Result && matches!(value, Value::Result(val::Result::Val(_))) { + return None; + } + // Create an evaluator variable and insert it. let var_id = self.resource_manager.next_var(); let eval_var = Var { @@ -3314,15 +3355,38 @@ impl<'a> PartialEvaluator<'a> { fn convert_value( &mut self, args_value: &Value, - variable: rir::Variable, + args_span: PackageSpan, ) -> Result { - let instruction = - Instruction::Convert(self.map_eval_value_to_rir_operand(args_value), variable); - let current_block = self.get_current_rir_block_mut(); - current_block.0.push(instruction); - Ok(Value::Var( - map_rir_var_to_eval_var(variable).expect("variable should convert"), - )) + match args_value { + Value::Var(var) => { + let variable_id = self.resource_manager.next_var(); + let variable = match var.ty { + VarTy::Double => rir::Variable::new_integer(variable_id), + VarTy::Integer => rir::Variable::new_double(variable_id), + _ => { + return Err(Error::Unimplemented( + format!("unsupported variable type in conversion {:?}", var.ty), + args_span, + )); + } + }; + let instruction = + Instruction::Convert(self.map_eval_value_to_rir_operand(args_value), variable); + let current_block = self.get_current_rir_block_mut(); + current_block.0.push(instruction); + Ok(Value::Var( + map_rir_var_to_eval_var(variable).expect("variable should convert"), + )) + } + #[allow(clippy::cast_precision_loss)] + Value::Int(i) => Ok(Value::Double(*i as f64)), + #[allow(clippy::cast_possible_truncation)] + Value::Double(d) => Ok(Value::Int(*d as i64)), + _ => Err(Error::Unimplemented( + format!("unsupported value type in conversion {args_value:?}"), + args_span, + )), + } } fn update_bindings(&mut self, lhs_expr_id: ExprId, rhs_value: Value) -> Result<(), Error> { @@ -3388,8 +3452,14 @@ impl<'a> PartialEvaluator<'a> { // Insert a store instruction when the value of a variable is updated. let rhs_operand = self.map_eval_value_to_rir_operand(&value); let rir_var = map_eval_var_to_rir_var(*var); - let store_ins = Instruction::Store(rhs_operand, rir_var); - self.get_current_rir_block_mut().0.push(store_ins); + + // We only want to emit a store instruction if that does not involve storing a boolean literal into a result variable. + // Result literals are rendered as boolean but are not expected to be emitted into the RIR, as QIR does not support the notion + // of a result literal. + if !(var.ty == VarTy::Result && matches!(value, Value::Result(val::Result::Val(_)))) { + let store_ins = Instruction::Store(rhs_operand, rir_var); + self.get_current_rir_block_mut().0.push(store_ins); + } // If this is a mutable variable, make sure to update whether it is static or dynamic. let current_scope = self.eval_context.get_current_scope_mut(); @@ -3547,6 +3617,7 @@ impl<'a> PartialEvaluator<'a> { Ty::Prim(Prim::Bool) => (self.get_bool_record_callable(), "b"), Ty::Prim(Prim::Int) => (self.get_int_record_callable(), "i"), Ty::Prim(Prim::Double) => (self.get_double_record_callable(), "d"), + Ty::Prim(Prim::Result) => (self.get_result_record_callable(), "r"), _ => panic!("unsupported variable type in output recording"), }; let tag = format!("{idx}_{tag_root}{tag_ty}"); @@ -4130,13 +4201,6 @@ fn eval_bin_op_with_double_literals( rhs_literal: Literal, bin_op_expr_span: PackageSpan, // For diagnostic purposes only ) -> Result { - fn eval_double_div(lhs: f64, rhs: f64, span: PackageSpan) -> Result { - match (lhs, rhs) { - (_, 0.0) => Err(EvalError::DivZero(span).into()), - (lhs, rhs) => Ok(Value::Double(lhs / rhs)), - } - } - // Validate that both literals are doubles. let (Literal::Double(lhs), Literal::Double(rhs)) = (lhs_literal, rhs_literal) else { panic!("at least one literal is not an double: {lhs_literal}, {rhs_literal}"); @@ -4160,7 +4224,14 @@ fn eval_bin_op_with_double_literals( BinOp::Add => Ok(Value::Double(lhs + rhs)), BinOp::Sub => Ok(Value::Double(lhs - rhs)), BinOp::Mul => Ok(Value::Double(lhs * rhs)), - BinOp::Div => eval_double_div(lhs, rhs, bin_op_expr_span), + BinOp::Div => match (lhs, rhs) { + (_, 0.0) => Err(EvalError::DivZero(bin_op_expr_span).into()), + (lhs, rhs) => Ok(Value::Double(lhs / rhs)), + }, + BinOp::Mod => match (lhs, rhs) { + (_, 0.0) => Err(EvalError::DivZero(bin_op_expr_span).into()), + (lhs, rhs) => Ok(Value::Double(lhs % rhs)), + }, _ => panic!("invalid double operator: {bin_op:?}"), } } @@ -4254,6 +4325,7 @@ fn map_eval_var_type_to_rir_type(var_ty: VarTy) -> rir::Ty { VarTy::Integer => rir::Ty::Prim(rir::Prim::Integer), VarTy::Double => rir::Ty::Prim(rir::Prim::Double), VarTy::Qubit => rir::Ty::Prim(rir::Prim::Qubit), + VarTy::Result => rir::Ty::Prim(rir::Prim::Result), } } @@ -4268,11 +4340,16 @@ fn map_fir_type_to_rir_type(ty: &Ty) -> Result { } } -fn map_rir_literal_to_eval_value(literal: rir::Literal) -> Value { +fn map_rir_literal_to_eval_value(literal: rir::Literal, var_ty: VarTy) -> Value { match literal { - rir::Literal::Bool(b) => Value::Bool(b), + rir::Literal::Bool(b) => match var_ty { + VarTy::Boolean => Value::Bool(b), + VarTy::Result => Value::Result(val::Result::Val(b)), + _ => panic!("Incompatible literal and variable types: {literal}, {var_ty}"), + }, rir::Literal::Double(d) => Value::Double(d), rir::Literal::Integer(i) => Value::Int(i), + rir::Literal::Result(r) => Value::Result(val::Result::Id(r as usize)), _ => panic!("{literal:?} RIR literal cannot be mapped to evaluator value"), } } @@ -4290,6 +4367,7 @@ fn map_rir_type_to_eval_var_type(ty: rir::Ty) -> Result { rir::Ty::Prim(rir::Prim::Integer) => Ok(VarTy::Integer), rir::Ty::Prim(rir::Prim::Double) => Ok(VarTy::Double), rir::Ty::Prim(rir::Prim::Qubit) => Ok(VarTy::Qubit), + rir::Ty::Prim(rir::Prim::Result) => Ok(VarTy::Result), _ => Err(()), } } @@ -4300,6 +4378,7 @@ fn try_get_eval_var_type(value: &Value) -> Option { Value::Int(_) => Some(VarTy::Integer), Value::Double(_) => Some(VarTy::Double), Value::Qubit(_) => Some(VarTy::Qubit), + Value::Result(_) => Some(VarTy::Result), Value::Var(var) => Some(var.ty), _ => None, } diff --git a/source/compiler/qsc_partial_eval/src/tests.rs b/source/compiler/qsc_partial_eval/src/tests.rs index d32db7eb31..08e66af366 100644 --- a/source/compiler/qsc_partial_eval/src/tests.rs +++ b/source/compiler/qsc_partial_eval/src/tests.rs @@ -83,7 +83,7 @@ pub fn get_partial_evaluation_error_with_capabilities( }, ); match maybe_program { - Ok(_) => panic!("partial evaluation succeeded"), + Ok(program) => panic!("partial evaluation succeeded: {program}"), Err(error) => error, } } diff --git a/source/compiler/qsc_partial_eval/src/tests/bindings.rs b/source/compiler/qsc_partial_eval/src/tests/bindings.rs index c1eb44571d..b0977df513 100644 --- a/source/compiler/qsc_partial_eval/src/tests/bindings.rs +++ b/source/compiler/qsc_partial_eval/src/tests/bindings.rs @@ -64,7 +64,7 @@ fn immutable_result_binding_does_not_generate_store_instruction() { } #[test] -fn mutable_result_binding_does_not_generate_store_instruction() { +fn mutable_result_binding_generates_store_instruction() { let program = get_rir_program(indoc! {r#" namespace Test { @EntryPoint() @@ -109,6 +109,7 @@ fn mutable_result_binding_does_not_generate_store_instruction() { Block: Call id(1), args( Pointer, ) Call id(2), args( Qubit(0), Result(0), ) + Variable(0, Result) = Store Result(0) Call id(3), args( Result(0), Tag(0, 3), ) Return"#]], ); diff --git a/source/compiler/qsc_partial_eval/src/tests/branching.rs b/source/compiler/qsc_partial_eval/src/tests/branching.rs index 2a76ed0897..9f235bfcab 100644 --- a/source/compiler/qsc_partial_eval/src/tests/branching.rs +++ b/source/compiler/qsc_partial_eval/src/tests/branching.rs @@ -1306,28 +1306,6 @@ fn if_else_expression_with_dynamic_condition_and_subsequent_call_to_operation() ); } -#[test] -fn if_else_expression_with_result_literal_fails() { - let error = get_partial_evaluation_error(indoc! { - r#" - namespace Test { - @EntryPoint() - operation Main() : Result { - use q = Qubit(); - MResetZ(q) == One ? One | MResetZ(q) - } - } - "#, - }); - - assert_error( - &error, - &expect![[ - r#"Unexpected("dynamic value of type Result in conditional expression", PackageSpan { package: PackageId(2), span: Span { lo: 101, hi: 137 } })"# - ]], - ); -} - #[test] fn if_expression_with_classical_operand_from_hybrid_results_array_comparing_to_literal_zero() { let program = get_rir_program(indoc! {r#" diff --git a/source/compiler/qsc_partial_eval/src/tests/loops.rs b/source/compiler/qsc_partial_eval/src/tests/loops.rs index db07f4d246..baff5adff4 100644 --- a/source/compiler/qsc_partial_eval/src/tests/loops.rs +++ b/source/compiler/qsc_partial_eval/src/tests/loops.rs @@ -1610,6 +1610,118 @@ fn result_array_index_range_in_for_loop_unrolled() { "#]].assert_eq(&program.to_string()); } +#[test] +fn result_array_index_range_in_for_loop() { + let program = get_rir_program_with_capabilities( + indoc! {r#" + namespace Test { + @EntryPoint() + operation Main() : Int { + use qs = Qubit[2]; + let results = MResetEachZ(qs); + mutable count = 0; + for i in Std.Arrays.IndexRange(results) { + if results[i] == One { + set count += 1; + } + } + count + } + } + "#}, + Profile::AdaptiveRIFLA.into(), + ); + expect![[r#" + Program: + entry: 0 + callables: + Callable 0: Callable: + name: main + call_type: Regular + input_type: + output_type: Integer + body: 0 + Callable 1: Callable: + name: __quantum__rt__initialize + call_type: Regular + input_type: + [0]: Pointer + output_type: + body: + Callable 2: Callable: + name: __quantum__qis__mresetz__body + call_type: Measurement + input_type: + [0]: Qubit + [1]: Result + output_type: + body: + Callable 3: Callable: + name: __quantum__rt__read_result + call_type: Readout + input_type: + [0]: Result + output_type: Boolean + body: + Callable 4: Callable: + name: __quantum__rt__int_record_output + call_type: OutputRecording + input_type: + [0]: Integer + [1]: Pointer + output_type: + body: + blocks: + Block 0: Block: + Call id(1), args( Pointer, ) + Variable(0, Integer) = Store Integer(0) + Variable(0, Integer) = Store Integer(1) + Variable(0, Integer) = Store Integer(2) + Variable(1, Integer) = Store Integer(0) + Call id(2), args( Qubit(0), Result(0), ) + Variable(1, Integer) = Store Integer(1) + Call id(2), args( Qubit(1), Result(1), ) + Variable(1, Integer) = Store Integer(2) + Variable(2, Integer) = Store Integer(0) + Variable(3, Integer) = Store Integer(0) + Jump(1) + Block 1: Block: + Variable(4, Boolean) = Icmp Sle, Variable(3, Integer), Integer(1) + Variable(5, Boolean) = Store Bool(true) + Branch Variable(4, Boolean), 3, 4 + Block 2: Block: + Variable(11, Integer) = Store Variable(2, Integer) + Call id(4), args( Variable(11, Integer), Tag(0, 3), ) + Return + Block 3: Block: + Branch Variable(5, Boolean), 5, 2 + Block 4: Block: + Variable(5, Boolean) = Store Bool(false) + Jump(3) + Block 5: Block: + Variable(6, Result) = Index Array(0), Variable(3, Integer) + Variable(7, Boolean) = Call id(3), args( Variable(6, Result), ) + Variable(8, Boolean) = Store Variable(7, Boolean) + Branch Variable(8, Boolean), 7, 6 + Block 6: Block: + Variable(10, Integer) = Add Variable(3, Integer), Integer(1) + Variable(3, Integer) = Store Variable(10, Integer) + Jump(1) + Block 7: Block: + Variable(9, Integer) = Add Variable(2, Integer), Integer(1) + Variable(2, Integer) = Store Variable(9, Integer) + Jump(6) + config: Config: + capabilities: TargetCapabilityFlags(Adaptive | IntegerComputations | FloatingPointComputations | BackwardsBranching | StaticSizedArrays) + num_qubits: 2 + num_results: 2 + tags: + [0]: 0_i + array_literals: + [0]: [Result(0), Result(1)] + "#]].assert_eq(&program.to_string()); +} + #[test] fn dynamic_while_loop() { let program = get_rir_program_with_capabilities( diff --git a/source/compiler/qsc_partial_eval/src/tests/misc.rs b/source/compiler/qsc_partial_eval/src/tests/misc.rs index 3958dfacf0..48f1e3a551 100644 --- a/source/compiler/qsc_partial_eval/src/tests/misc.rs +++ b/source/compiler/qsc_partial_eval/src/tests/misc.rs @@ -608,10 +608,15 @@ fn evaluation_error_within_stdlib_yield_correct_package_span() { namespace Test { import Std.Arrays.*; @EntryPoint() - operation Main() : Result[] { - use qs = Qubit[1]; - let rs = ForEach(MResetZ, qs); - return rs; + operation Main() : Int[] { + use q = Qubit(); + let a = if MResetZ(q) == One { + 1 + } else { + 0 + }; + let b = [(a, a)]; + ForEach(t => Fst(t), b) } } "#, diff --git a/source/compiler/qsc_passes/src/capabilitiesck.rs b/source/compiler/qsc_passes/src/capabilitiesck.rs index 2bf707903d..0700fc88a3 100644 --- a/source/compiler/qsc_passes/src/capabilitiesck.rs +++ b/source/compiler/qsc_passes/src/capabilitiesck.rs @@ -13,6 +13,9 @@ mod tests_adaptive_plus_integers; #[cfg(test)] mod tests_adaptive_plus_integers_and_floats; +#[cfg(test)] +mod tests_adaptive_plus_integers_and_floats_and_loops; + #[cfg(test)] pub mod tests_common; diff --git a/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive.rs b/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive.rs index 743240a038..d43a6382b2 100644 --- a/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive.rs +++ b/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive.rs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +use crate::capabilitiesck::tests_common::DYNAMIC_RESULT_LITERAL; + use super::tests_common::{ CALL_DYNAMIC_FUNCTION, CALL_DYNAMIC_OPERATION, CALL_TO_CYCLIC_FUNCTION_WITH_CLASSICAL_ARGUMENT, CALL_TO_CYCLIC_FUNCTION_WITH_DYNAMIC_ARGUMENT, @@ -790,3 +792,26 @@ fn binary_op_with_dynamic_array_succeeds() { "#]], ); } + +#[test] +fn use_of_dynamic_result_literal_errors() { + check_profile( + DYNAMIC_RESULT_LITERAL, + &expect![[r#" + [ + UseOfDynamicResult( + Span { + lo: 98, + hi: 190, + }, + ), + UseOfStaticResultInVariable( + Span { + lo: 98, + hi: 190, + }, + ), + ] + "#]], + ); +} diff --git a/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers.rs b/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers.rs index b1c055d2ec..59edb365a9 100644 --- a/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers.rs +++ b/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers.rs @@ -1,7 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -use crate::capabilitiesck::tests_common::USE_DYNAMIC_RANGE; +use crate::capabilitiesck::tests_common::{DYNAMIC_RESULT_LITERAL, USE_DYNAMIC_RANGE}; use super::tests_common::{ CALL_DYNAMIC_FUNCTION, CALL_DYNAMIC_OPERATION, CALL_TO_CYCLIC_FUNCTION_WITH_CLASSICAL_ARGUMENT, @@ -19,22 +19,14 @@ use super::tests_common::{ USE_ENTRY_POINT_STATIC_RANGE, USE_ENTRY_POINT_STATIC_STRING, check, check_for_exe, }; use expect_test::{Expect, expect}; -use qsc_data_structures::target::TargetCapabilityFlags; +use qsc_data_structures::target::Profile; fn check_profile(source: &str, expect: &Expect) { - check( - source, - expect, - TargetCapabilityFlags::Adaptive | TargetCapabilityFlags::IntegerComputations, - ); + check(source, expect, Profile::AdaptiveRI.into()); } fn check_profile_for_exe(source: &str, expect: &Expect) { - check_for_exe( - source, - expect, - TargetCapabilityFlags::Adaptive | TargetCapabilityFlags::IntegerComputations, - ); + check_for_exe(source, expect, Profile::AdaptiveRI.into()); } #[test] @@ -627,3 +619,26 @@ fn use_of_static_sized_array_in_tuple_allowed() { "#]], ); } + +#[test] +fn use_of_dynamic_result_literal_errors() { + check_profile( + DYNAMIC_RESULT_LITERAL, + &expect![[r#" + [ + UseOfDynamicResult( + Span { + lo: 98, + hi: 190, + }, + ), + UseOfStaticResultInVariable( + Span { + lo: 98, + hi: 190, + }, + ), + ] + "#]], + ); +} diff --git a/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers_and_floats.rs b/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers_and_floats.rs index bcd333d0ab..064c8f0c23 100644 --- a/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers_and_floats.rs +++ b/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers_and_floats.rs @@ -1,7 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. -use crate::capabilitiesck::tests_common::USE_DYNAMIC_RANGE; +use crate::capabilitiesck::tests_common::{DYNAMIC_RESULT_LITERAL, USE_DYNAMIC_RANGE}; use super::tests_common::{ CALL_DYNAMIC_FUNCTION, CALL_DYNAMIC_OPERATION, CALL_TO_CYCLIC_FUNCTION_WITH_CLASSICAL_ARGUMENT, @@ -19,26 +19,14 @@ use super::tests_common::{ USE_ENTRY_POINT_STATIC_RANGE, USE_ENTRY_POINT_STATIC_STRING, check, check_for_exe, }; use expect_test::{Expect, expect}; -use qsc_data_structures::target::TargetCapabilityFlags; +use qsc_data_structures::target::Profile; fn check_profile(source: &str, expect: &Expect) { - check( - source, - expect, - TargetCapabilityFlags::Adaptive - | TargetCapabilityFlags::IntegerComputations - | TargetCapabilityFlags::FloatingPointComputations, - ); + check(source, expect, Profile::AdaptiveRIF.into()); } fn check_profile_for_exe(source: &str, expect: &Expect) { - check_for_exe( - source, - expect, - TargetCapabilityFlags::Adaptive - | TargetCapabilityFlags::IntegerComputations - | TargetCapabilityFlags::FloatingPointComputations, - ); + check_for_exe(source, expect, Profile::AdaptiveRIF.into()); } #[test] @@ -605,3 +593,26 @@ fn use_of_static_sized_array_in_tuple_allowed() { "#]], ); } + +#[test] +fn use_of_dynamic_result_literal_errors() { + check_profile( + DYNAMIC_RESULT_LITERAL, + &expect![[r#" + [ + UseOfDynamicResult( + Span { + lo: 98, + hi: 190, + }, + ), + UseOfStaticResultInVariable( + Span { + lo: 98, + hi: 190, + }, + ), + ] + "#]], + ); +} diff --git a/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers_and_floats_and_loops.rs b/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers_and_floats_and_loops.rs new file mode 100644 index 0000000000..1910797581 --- /dev/null +++ b/source/compiler/qsc_passes/src/capabilitiesck/tests_adaptive_plus_integers_and_floats_and_loops.rs @@ -0,0 +1,592 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use crate::capabilitiesck::tests_common::{DYNAMIC_RESULT_LITERAL, USE_DYNAMIC_RANGE}; + +use super::tests_common::{ + CALL_DYNAMIC_FUNCTION, CALL_DYNAMIC_OPERATION, CALL_TO_CYCLIC_FUNCTION_WITH_CLASSICAL_ARGUMENT, + CALL_TO_CYCLIC_FUNCTION_WITH_DYNAMIC_ARGUMENT, + CALL_TO_CYCLIC_OPERATION_WITH_CLASSICAL_ARGUMENT, + CALL_TO_CYCLIC_OPERATION_WITH_DYNAMIC_ARGUMENT, CALL_UNRESOLVED_FUNCTION, CUSTOM_MEASUREMENT, + LOOP_WITH_DYNAMIC_CONDITION, MEASUREMENT_WITHIN_DYNAMIC_SCOPE, MINIMAL, + RETURN_WITHIN_DYNAMIC_SCOPE, USE_CLOSURE_FUNCTION, USE_DYNAMIC_BIG_INT, USE_DYNAMIC_BOOLEAN, + USE_DYNAMIC_DOUBLE, USE_DYNAMIC_FUNCTION, USE_DYNAMIC_INDEX, USE_DYNAMIC_INT, + USE_DYNAMIC_LHS_EXP_BINOP, USE_DYNAMIC_OPERATION, USE_DYNAMIC_PAULI, USE_DYNAMIC_QUBIT, + USE_DYNAMIC_RHS_EXP_BINOP, USE_DYNAMIC_STRING, USE_DYNAMIC_UDT, USE_DYNAMICALLY_SIZED_ARRAY, + USE_ENTRY_POINT_INT_ARRAY_IN_TUPLE, USE_ENTRY_POINT_STATIC_BIG_INT, + USE_ENTRY_POINT_STATIC_BOOL, USE_ENTRY_POINT_STATIC_DOUBLE, USE_ENTRY_POINT_STATIC_INT, + USE_ENTRY_POINT_STATIC_INT_IN_TUPLE, USE_ENTRY_POINT_STATIC_PAULI, + USE_ENTRY_POINT_STATIC_RANGE, USE_ENTRY_POINT_STATIC_STRING, check, check_for_exe, +}; +use expect_test::{Expect, expect}; +use qsc_data_structures::target::Profile; + +fn check_profile(source: &str, expect: &Expect) { + check(source, expect, Profile::AdaptiveRIFLA.into()); +} + +fn check_profile_for_exe(source: &str, expect: &Expect) { + check_for_exe(source, expect, Profile::AdaptiveRIFLA.into()); +} + +#[test] +fn minimal_program_yields_no_errors() { + check_profile( + MINIMAL, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamic_boolean_yields_no_errors() { + check_profile( + USE_DYNAMIC_BOOLEAN, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamic_int_yields_no_errors() { + check_profile( + USE_DYNAMIC_INT, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamic_pauli_yields_error() { + check_profile( + USE_DYNAMIC_PAULI, + &expect![[r#" + [ + UseOfDynamicPauli( + Span { + lo: 104, + hi: 134, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_dynamic_range_yields_error() { + check_profile( + USE_DYNAMIC_RANGE, + &expect![[r#" + [ + UseOfDynamicRange( + Span { + lo: 108, + hi: 137, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_dynamic_double_yields_no_errors() { + check_profile( + USE_DYNAMIC_DOUBLE, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamic_qubit_yields_errors() { + check_profile( + USE_DYNAMIC_QUBIT, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamic_big_int_yields_errors() { + check_profile( + USE_DYNAMIC_BIG_INT, + &expect![[r#" + [ + UseOfDynamicBigInt( + Span { + lo: 227, + hi: 265, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_dynamic_string_yields_errors() { + check_profile( + USE_DYNAMIC_STRING, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamically_sized_array_yields_error() { + check_profile( + USE_DYNAMICALLY_SIZED_ARRAY, + &expect![[r#" + [ + UseOfDynamicallySizedArray( + Span { + lo: 104, + hi: 136, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_dynamic_udt_yields_errors() { + check_profile( + USE_DYNAMIC_UDT, + &expect![[r#" + [ + UseOfDynamicUdt( + Span { + lo: 253, + hi: 305, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_dynamic_function_yields_errors() { + check_profile( + USE_DYNAMIC_FUNCTION, + &expect![[r#" + [ + UseOfDynamicArrowFunction( + Span { + lo: 132, + hi: 156, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_dynamic_operation_yields_errors() { + check_profile( + USE_DYNAMIC_OPERATION, + &expect![[r#" + [ + UseOfDynamicArrowOperation( + Span { + lo: 132, + hi: 152, + }, + ), + ] + "#]], + ); +} + +#[test] +fn call_cyclic_function_with_classical_argument_yields_no_errors() { + check_profile( + CALL_TO_CYCLIC_FUNCTION_WITH_CLASSICAL_ARGUMENT, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn call_cyclic_function_with_dynamic_argument_yields_error() { + check_profile( + CALL_TO_CYCLIC_FUNCTION_WITH_DYNAMIC_ARGUMENT, + &expect![[r#" + [ + CallToCyclicFunctionWithDynamicArg( + Span { + lo: 211, + hi: 243, + }, + ), + ] + "#]], + ); +} + +#[test] +fn call_cyclic_operation_with_classical_argument_yields_errors() { + check_profile( + CALL_TO_CYCLIC_OPERATION_WITH_CLASSICAL_ARGUMENT, + &expect![[r#" + [ + CyclicOperationSpec( + Span { + lo: 15, + hi: 23, + }, + ), + CallToCyclicOperation( + Span { + lo: 187, + hi: 199, + }, + ), + ] + "#]], + ); +} + +#[test] +fn call_cyclic_operation_with_dynamic_argument_yields_errors() { + check_profile( + CALL_TO_CYCLIC_OPERATION_WITH_DYNAMIC_ARGUMENT, + &expect![[r#" + [ + CyclicOperationSpec( + Span { + lo: 15, + hi: 23, + }, + ), + CallToCyclicOperation( + Span { + lo: 212, + hi: 244, + }, + ), + ] + "#]], + ); +} + +#[test] +fn call_to_dynamic_function_yields_errors() { + check_profile( + CALL_DYNAMIC_FUNCTION, + &expect![[r#" + [ + UseOfDynamicArrowFunction( + Span { + lo: 132, + hi: 156, + }, + ), + UseOfDynamicArrowFunction( + Span { + lo: 170, + hi: 178, + }, + ), + CallToDynamicCallee( + Span { + lo: 170, + hi: 178, + }, + ), + ] + "#]], + ); +} + +#[test] +fn call_to_dynamic_operation_yields_errors() { + check_profile( + CALL_DYNAMIC_OPERATION, + &expect![[r#" + [ + UseOfDynamicArrowOperation( + Span { + lo: 132, + hi: 152, + }, + ), + UseOfDynamicArrowOperation( + Span { + lo: 166, + hi: 171, + }, + ), + CallToDynamicCallee( + Span { + lo: 166, + hi: 171, + }, + ), + ] + "#]], + ); +} + +#[test] +fn call_to_unresolved_allowed() { + check_profile( + CALL_UNRESOLVED_FUNCTION, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn measurement_within_dynamic_scope_yields_no_errors() { + check_profile( + MEASUREMENT_WITHIN_DYNAMIC_SCOPE, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn custom_measurement_yields_no_errors() { + check_profile( + CUSTOM_MEASUREMENT, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamic_index_yields_errors() { + check_profile( + USE_DYNAMIC_INDEX, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamic_lhs_exp_binop_allowed() { + check_profile( + USE_DYNAMIC_LHS_EXP_BINOP, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamic_rhs_exp_binop_yields_errors() { + check_profile( + USE_DYNAMIC_RHS_EXP_BINOP, + &expect![[r#" + [ + UseOfDynamicExponent( + Span { + lo: 138, + hi: 143, + }, + ), + ] + "#]], + ); +} + +#[test] +fn return_within_dynamic_scope_yields_errors() { + check_profile( + RETURN_WITHIN_DYNAMIC_SCOPE, + &expect![[r#" + [ + ReturnWithinDynamicScope( + Span { + lo: 128, + hi: 136, + }, + ), + ] + "#]], + ); +} + +#[test] +fn loop_with_dynamic_condition_yields_errors() { + check_profile( + LOOP_WITH_DYNAMIC_CONDITION, + &expect![[r#" + [ + UseOfDynamicRange( + Span { + lo: 141, + hi: 159, + }, + ), + UseOfDynamicRange( + Span { + lo: 150, + hi: 156, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_closure_allowed() { + check_profile( + USE_CLOSURE_FUNCTION, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_static_int_return_from_entry_point_allowed() { + check_profile_for_exe( + USE_ENTRY_POINT_STATIC_INT, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_static_double_return_from_entry_point_errors() { + check_profile_for_exe( + USE_ENTRY_POINT_STATIC_DOUBLE, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_static_string_return_from_entry_point_errors() { + check_profile_for_exe( + USE_ENTRY_POINT_STATIC_STRING, + &expect![[r#" + [ + UseOfAdvancedOutput( + Span { + lo: 63, + hi: 66, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_static_bool_return_from_entry_point_supported() { + check_profile_for_exe( + USE_ENTRY_POINT_STATIC_BOOL, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_static_big_int_return_from_entry_point_errors() { + check_profile_for_exe( + USE_ENTRY_POINT_STATIC_BIG_INT, + &expect![[r#" + [ + UseOfAdvancedOutput( + Span { + lo: 63, + hi: 66, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_static_pauli_return_from_entry_point_errors() { + check_profile_for_exe( + USE_ENTRY_POINT_STATIC_PAULI, + &expect![[r#" + [ + UseOfAdvancedOutput( + Span { + lo: 63, + hi: 66, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_static_range_return_from_entry_point_errors() { + check_profile_for_exe( + USE_ENTRY_POINT_STATIC_RANGE, + &expect![[r#" + [ + UseOfAdvancedOutput( + Span { + lo: 63, + hi: 66, + }, + ), + ] + "#]], + ); +} + +#[test] +fn use_of_static_int_in_tuple_return_from_entry_point_allowed() { + check_profile_for_exe( + USE_ENTRY_POINT_STATIC_INT_IN_TUPLE, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_static_sized_array_in_tuple_allowed() { + check_profile_for_exe( + USE_ENTRY_POINT_INT_ARRAY_IN_TUPLE, + &expect![[r#" + [] + "#]], + ); +} + +#[test] +fn use_of_dynamic_result_literal_errors() { + check_profile( + DYNAMIC_RESULT_LITERAL, + &expect![[r#" + [ + UseOfStaticResultInVariable( + Span { + lo: 98, + hi: 190, + }, + ), + ] + "#]], + ); +} diff --git a/source/compiler/qsc_passes/src/capabilitiesck/tests_base.rs b/source/compiler/qsc_passes/src/capabilitiesck/tests_base.rs index 4fa3dad001..b8816c2dbc 100644 --- a/source/compiler/qsc_passes/src/capabilitiesck/tests_base.rs +++ b/source/compiler/qsc_passes/src/capabilitiesck/tests_base.rs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +use crate::capabilitiesck::tests_common::DYNAMIC_RESULT_LITERAL; + use super::tests_common::{ CALL_DYNAMIC_FUNCTION, CALL_DYNAMIC_OPERATION, CALL_TO_CYCLIC_FUNCTION_WITH_CLASSICAL_ARGUMENT, CALL_TO_CYCLIC_FUNCTION_WITH_DYNAMIC_ARGUMENT, @@ -976,3 +978,26 @@ fn binary_op_with_dynamic_array_error() { "#]], ); } + +#[test] +fn use_of_dynamic_result_literal_errors() { + check_profile( + DYNAMIC_RESULT_LITERAL, + &expect![[r#" + [ + UseOfDynamicBool( + Span { + lo: 101, + hi: 112, + }, + ), + MeasurementWithinDynamicScope( + Span { + lo: 172, + hi: 176, + }, + ), + ] + "#]], + ); +} diff --git a/source/compiler/qsc_passes/src/capabilitiesck/tests_common.rs b/source/compiler/qsc_passes/src/capabilitiesck/tests_common.rs index 0d557b02c3..c596f125b9 100644 --- a/source/compiler/qsc_passes/src/capabilitiesck/tests_common.rs +++ b/source/compiler/qsc_passes/src/capabilitiesck/tests_common.rs @@ -528,3 +528,15 @@ pub const DYNAMIC_ARRAY_BINARY_OP: &str = r#" MResetEachZ(qs) == [Zero, Zero]; } "#; + +pub const DYNAMIC_RESULT_LITERAL: &str = r#" + namespace Test { + operation Foo() : Result { + use q = Qubit(); + if M(q) == One { + One + } else { + M(q) + } + } + }"#; diff --git a/source/compiler/qsc_rca/src/applications.rs b/source/compiler/qsc_rca/src/applications.rs index be1a3786af..656de9a518 100644 --- a/source/compiler/qsc_rca/src/applications.rs +++ b/source/compiler/qsc_rca/src/applications.rs @@ -33,7 +33,7 @@ impl GeneratorSetsBuilder { // application. For array parameters it is a three-element vector and for the parameters of any other type it // is a single-element vector. let mut application_instances = - Vec::>::with_capacity(input_params.len() + 1); + Vec::>::with_capacity((input_params.len() * 2) + 1); // Insert the inherent application instance. application_instances.push(vec![ApplicationInstance::new( @@ -47,9 +47,10 @@ impl GeneratorSetsBuilder { for input_param in input_params { let input_param_variants = match input_param.ty { Ty::Array(_) => { - // For parameters of type array, two dynamic variants exist: + // For parameters of type array, three dynamic variants exist: // - An array with dynamic content and static size. // - An array with dynamic content and dynamic size. + // - An array with constant content. let dynamic_content_static_size = ApplicationInstance::new( input_params, controls, @@ -74,11 +75,7 @@ impl GeneratorSetsBuilder { }, )), ); - vec![dynamic_content_static_size, dynamic_content_dynamic_size] - } - _ => { - // For non-array params, only one dynamic variant exists. - vec![ApplicationInstance::new( + let constant_content = ApplicationInstance::new( input_params, controls, return_type, @@ -86,10 +83,43 @@ impl GeneratorSetsBuilder { input_param.index, ComputeKind::Dynamic { runtime_features: RuntimeFeatureFlags::empty(), - value_kind: ValueKind::Variable, + value_kind: ValueKind::Constant, }, )), - )] + ); + vec![ + dynamic_content_static_size, + dynamic_content_dynamic_size, + constant_content, + ] + } + _ => { + vec![ + ApplicationInstance::new( + input_params, + controls, + return_type, + Some(( + input_param.index, + ComputeKind::Dynamic { + runtime_features: RuntimeFeatureFlags::empty(), + value_kind: ValueKind::Constant, + }, + )), + ), + ApplicationInstance::new( + input_params, + controls, + return_type, + Some(( + input_param.index, + ComputeKind::Dynamic { + runtime_features: RuntimeFeatureFlags::empty(), + value_kind: ValueKind::Variable, + }, + )), + ), + ] } }; application_instances.push(input_param_variants); @@ -218,6 +248,15 @@ impl GeneratorSetsBuilder { .dynamic_size .aggregate_value_kind(*value_kind); }); + array_compute_properties + .constant_content + .value_kind + .iter() + .for_each(|value_kind| { + array_param_application + .constant_content + .aggregate_value_kind(*value_kind); + }); } crate::ParamApplication::Element(element_param_application) => { let ParamApplicationComputeProperties::Element(element_compute_properties) = @@ -226,10 +265,22 @@ impl GeneratorSetsBuilder { panic!("expected an element param application"); }; element_compute_properties + .constant + .value_kind + .iter() + .for_each(|value_kind| { + element_param_application + .constant + .aggregate_value_kind(*value_kind); + }); + element_compute_properties + .variable .value_kind .iter() .for_each(|value_kind| { - element_param_application.aggregate_value_kind(*value_kind); + element_param_application + .variable + .aggregate_value_kind(*value_kind); }); } } @@ -245,8 +296,8 @@ impl GeneratorSetsBuilder { } fn close_param(&mut self, param_index: InputParamIndex) -> ParamApplicationComputeProperties { - const DYNAMIC_ELEMENTS_PARAM_VARIANTS: usize = 1; - const DYNAMIC_ARRAY_PARAM_VARIANTS: usize = 2; + const DYNAMIC_ELEMENTS_PARAM_VARIANTS: usize = 2; + const DYNAMIC_ARRAY_PARAM_VARIANTS: usize = 3; // We need to offset the index since the first top-level vector in application instances is reserved for the // inherent variant. @@ -257,14 +308,26 @@ impl GeneratorSetsBuilder { // The kind of parameter application we create depends on the number of variants that the parameter has. if variants.len() == DYNAMIC_ELEMENTS_PARAM_VARIANTS { - let application_instance = variants + // IMPORTANT: the position of each application instance in the variants vector has a specific meaning, so + // we need the order of pops to remain consistent. + let variable_application_instance = variants .pop() .expect("element parameter application instance could not be popped"); - let compute_properties = application_instance.close(); - ParamApplicationComputeProperties::Element(compute_properties) + let constant_application_instance = variants + .pop() + .expect("element parameter application instance could not be popped"); + ParamApplicationComputeProperties::Element(Box::new( + ElemParamApplicationComputeProperties { + constant: constant_application_instance.close(), + variable: variable_application_instance.close(), + }, + )) } else if variants.len() == DYNAMIC_ARRAY_PARAM_VARIANTS { // IMPORTANT: the position of each application instance in the variants vector has a specific meaning, so // we need the order of pops to remain consistent. + let constant_content_application_instance = variants + .pop() + .expect("array parameter application instance could not be popped"); let dynamic_size_application_instance = variants .pop() .expect("array parameter application instance could not be popped"); @@ -275,6 +338,7 @@ impl GeneratorSetsBuilder { ArrayParamApplicationComputeProperties { static_size: static_size_application_instance.close(), dynamic_size: dynamic_size_application_instance.close(), + constant_content: constant_content_application_instance.close(), }, )) } else { @@ -647,7 +711,7 @@ impl ApplicationInstanceComputeProperties { } enum ParamApplicationComputeProperties { - Element(ApplicationInstanceComputeProperties), + Element(Box), Array(Box), } @@ -655,23 +719,33 @@ impl ParamApplicationComputeProperties { fn remove_item(&mut self, item: ApplicationInstanceItem) -> crate::ParamApplication { match self { Self::Element(compute_properties) => { - let compute_kind = compute_properties.remove(item); - crate::ParamApplication::Element(compute_kind) + // let compute_kind = compute_properties.remove(item); + let constant = compute_properties.constant.remove(item); + let variable = compute_properties.variable.remove(item); + crate::ParamApplication::Element(crate::ElemParamApplication { constant, variable }) } Self::Array(array_param) => { - let dynamic_content_static_size = array_param.static_size.remove(item); - let dynamic_content_dynamic_size = array_param.dynamic_size.remove(item); + let static_size = array_param.static_size.remove(item); + let dynamic_size = array_param.dynamic_size.remove(item); + let constant_content = array_param.constant_content.remove(item); crate::ParamApplication::Array(crate::ArrayParamApplication { - static_size: dynamic_content_static_size, - dynamic_size: dynamic_content_dynamic_size, + static_size, + dynamic_size, + constant_content, }) } } } } +struct ElemParamApplicationComputeProperties { + constant: ApplicationInstanceComputeProperties, + variable: ApplicationInstanceComputeProperties, +} + #[allow(clippy::struct_field_names)] struct ArrayParamApplicationComputeProperties { static_size: ApplicationInstanceComputeProperties, dynamic_size: ApplicationInstanceComputeProperties, + constant_content: ApplicationInstanceComputeProperties, } diff --git a/source/compiler/qsc_rca/src/core.rs b/source/compiler/qsc_rca/src/core.rs index 30f0b7da32..a7823833e3 100644 --- a/source/compiler/qsc_rca/src/core.rs +++ b/source/compiler/qsc_rca/src/core.rs @@ -3,7 +3,7 @@ use crate::{ ApplicationGeneratorSet, ArrayParamApplication, ComputeKind, ComputePropertiesLookup, - ParamApplication, RuntimeFeatureFlags, ValueKind, + ElemParamApplication, ParamApplication, RuntimeFeatureFlags, ValueKind, applications::{ApplicationInstance, GeneratorSetsBuilder, LocalComputeKind}, common::{ AssignmentStmtCounter, Callee, FunctorAppExt, GlobalSpecId, Local, LocalKind, @@ -19,9 +19,9 @@ use qsc_fir::{ extensions::InputParam, fir::{ Attr, BinOp, Block, BlockId, CallableDecl, CallableImpl, CallableKind, Expr, ExprId, - ExprKind, FieldAssign, Global, Ident, Item, ItemKind, LocalVarId, Mutability, Package, - PackageId, PackageLookup, PackageStore, PackageStoreLookup, Pat, PatId, PatKind, Res, - SpecDecl, SpecImpl, Stmt, StmtId, StmtKind, StoreExprId, StoreItemId, StorePatId, + ExprKind, Field, FieldAssign, Global, Ident, Item, ItemKind, LocalVarId, Mutability, + Package, PackageId, PackageLookup, PackageStore, PackageStoreLookup, Pat, PatId, PatKind, + Res, SpecDecl, SpecImpl, Stmt, StmtId, StmtKind, StoreExprId, StoreItemId, StorePatId, StringComponent, }, ty::{Arrow, FunctorSetValue, Prim, Ty}, @@ -260,12 +260,16 @@ impl<'a> Analyzer<'a> { value_kind, } = &mut compute_kind { + let lhs_expr_ty = &self.get_expr(lhs_expr_id).ty; + if is_any_result(lhs_expr_ty) { + *value_kind = ValueKind::Variable; + } + *runtime_features |= derive_runtime_features_for_value_kind_associated_to_type(*value_kind, expr_type); - let lhs_expr_ty = &self.get_expr(lhs_expr_id).ty; if *value_kind == ValueKind::Variable - && matches!(lhs_expr_ty, Ty::Prim(Prim::String)) + && *lhs_expr_ty == Ty::Prim(Prim::String) && expr_type == &Ty::Prim(Prim::Bool) { // Strings can only be concatenated or compared for equality, and only equality comparison @@ -614,7 +618,12 @@ impl<'a> Analyzer<'a> { compute_kind } - fn analyze_expr_field(&mut self, record_expr_id: ExprId, expr_type: &Ty) -> ComputeKind { + fn analyze_expr_field( + &mut self, + record_expr_id: ExprId, + expr_type: &Ty, + field: &Field, + ) -> ComputeKind { // Visit the record expression to determine its compute kind. self.visit_expr(record_expr_id); @@ -622,15 +631,24 @@ impl<'a> Analyzer<'a> { // the value kind adapted to the expression's type. let application_instance = self.get_current_application_instance(); let record_expr_compute_kind = *application_instance.get_expr_compute_kind(record_expr_id); - let runtime_kind = if record_expr_compute_kind.is_variable_value_kind() { - ValueKind::new_variable_from_type(expr_type) + let value_kind = if let ComputeKind::Dynamic { value_kind, .. } = record_expr_compute_kind { + if value_kind == ValueKind::Constant { + if matches!(field, Field::Prim(_)) { + // This is a special case: a primitive field is a range accessor, which for constant ranges + // should be treated as a static. + return ComputeKind::Static; + } + ValueKind::Constant + } else { + ValueKind::new_variable_from_type(expr_type) + } } else { ValueKind::Constant }; let mut compute_kind = ComputeKind::Static; compute_kind = - compute_kind.aggregate_runtime_features(record_expr_compute_kind, runtime_kind); + compute_kind.aggregate_runtime_features(record_expr_compute_kind, value_kind); compute_kind } @@ -679,14 +697,18 @@ impl<'a> Analyzer<'a> { compute_kind = compute_kind .aggregate_runtime_features(condition_expr_compute_kind, ValueKind::Constant); let body_expr_compute_kind = *application_instance.get_expr_compute_kind(body_expr_id); + let body_expr_is_static = matches!(body_expr_compute_kind, ComputeKind::Static); compute_kind = compute_kind.aggregate_runtime_features(body_expr_compute_kind, ValueKind::Constant); - if let Some(otherwise_expr_id) = otherwise_expr_id { + let otherwise_expr_is_static = if let Some(otherwise_expr_id) = otherwise_expr_id { let otherwise_expr_compute_kind = *application_instance.get_expr_compute_kind(otherwise_expr_id); compute_kind = compute_kind .aggregate_runtime_features(otherwise_expr_compute_kind, ValueKind::Constant); - } + matches!(otherwise_expr_compute_kind, ComputeKind::Static) + } else { + false + }; // If any of the sub-expressions is variable, then the compute kind of an if-expression is variable and additional // runtime features are aggregated. @@ -712,6 +734,10 @@ impl<'a> Analyzer<'a> { if condition_expr_compute_kind.is_variable_value_kind() { if is_any_result(expr_type) { dynamic_runtime_features |= RuntimeFeatureFlags::UseOfDynamicResult; + if body_expr_is_static || otherwise_expr_is_static { + dynamic_runtime_features |= + RuntimeFeatureFlags::UseOfStaticResultInVariable; + } } match expr_type { Ty::Tuple(tup) if !tup.is_empty() => { @@ -850,12 +876,18 @@ impl<'a> Analyzer<'a> { compute_kind = compute_kind.aggregate(step_expr_compute_kind); compute_kind = compute_kind.aggregate(end_expr_compute_kind); - // Additionally, if the compute kind of the range is variable, mark it with the appropriate runtime feature. - if compute_kind.is_variable_value_kind() { - compute_kind = compute_kind.aggregate(ComputeKind::Dynamic { - runtime_features: RuntimeFeatureFlags::UseOfDynamicRange, - value_kind: ValueKind::Constant, - }); + if let ComputeKind::Dynamic { + runtime_features, + value_kind, + } = &mut compute_kind + { + // Additionally, if the compute kind of the range is variable, mark it with the appropriate runtime feature. + if value_kind == &ValueKind::Variable { + *runtime_features |= RuntimeFeatureFlags::UseOfDynamicRange; + } else if runtime_features.is_empty() { + // If the runtime features are empty and the value is constant, we can treat the whole range as static. + compute_kind = ComputeKind::Static; + } } compute_kind } @@ -1174,13 +1206,18 @@ impl<'a> Analyzer<'a> { } }; - // If the condition is dynamic, we require an additional runtime feature. - if !matches!(condition_expr_compute_kind, ComputeKind::Static) { + // If the condition is dynamic, we may require an additional runtime feature. + if let ComputeKind::Dynamic { value_kind, .. } = condition_expr_compute_kind + && (value_kind == ValueKind::Variable + || self + .target_capabilities + .contains(TargetCapabilityFlags::BackwardsBranching)) + { let ComputeKind::Dynamic { runtime_features, .. } = &mut compute_kind else { - panic!("if the loop condition is quantum, the loop expression must be quantum too"); + panic!("if the loop condition is dynamic, the loop expression must be dynamic too"); }; *runtime_features |= RuntimeFeatureFlags::LoopWithDynamicCondition; } @@ -1930,8 +1967,8 @@ impl<'a> Visitor<'a> for Analyzer<'a> { } ExprKind::Closure(..) => ComputeKind::Static, ExprKind::Fail(msg_expr_id) => self.analyze_expr_fail(*msg_expr_id), - ExprKind::Field(record_expr_id, _) => { - self.analyze_expr_field(*record_expr_id, &expr.ty) + ExprKind::Field(record_expr_id, field) => { + self.analyze_expr_field(*record_expr_id, &expr.ty, field) } ExprKind::Hole | ExprKind::Lit(_) => { // Hole and literal expressions are always static. @@ -2278,7 +2315,10 @@ fn derive_intrinsic_function_application_generator_set( Ty::Array(_) => { array_param_application_from_runtime_features(runtime_features, value_kind) } - _ => ParamApplication::Element(param_compute_kind), + _ => ParamApplication::Element(ElemParamApplication { + constant: ComputeKind::Static, + variable: param_compute_kind, + }), }; dynamic_param_applications.push(param_application); } @@ -2303,6 +2343,10 @@ fn array_param_application_from_runtime_features( runtime_features: runtime_features | RuntimeFeatureFlags::UseOfDynamicallySizedArray, value_kind, }, + constant_content: ComputeKind::Dynamic { + runtime_features: RuntimeFeatureFlags::empty(), + value_kind: ValueKind::Constant, + }, }) } @@ -2311,10 +2355,12 @@ fn derive_instrinsic_operation_application_generator_set( ) -> ApplicationGeneratorSet { assert!(matches!(callable_context.kind, CallableKind::Operation)); - // The value kind of intrinsic operations is inherently dynamic if their output is not `Unit` or `Qubit`. - let runtime_kind = if callable_context.output_type == Ty::UNIT - || callable_context.output_type == Ty::Prim(Prim::Qubit) - { + // The value kind of intrinsic operations is inherently dynamic if their output is not `Unit`, `Qubit` or `Result`. + let inherent_value_kind = if callable_context.output_type == Ty::UNIT + || matches!( + callable_context.output_type, + Ty::Prim(Prim::Qubit | Prim::Result) + ) { ValueKind::Constant } else { ValueKind::new_variable_from_type(&callable_context.output_type) @@ -2331,7 +2377,7 @@ fn derive_instrinsic_operation_application_generator_set( // The compute kind of intrinsic operations is always dynamic. let inherent_compute_kind = ComputeKind::Dynamic { runtime_features: inherent_runtime_features, - value_kind: runtime_kind, + value_kind: inherent_value_kind, }; // Determine the compute kind of all dynamic parameter applications. @@ -2339,14 +2385,18 @@ fn derive_instrinsic_operation_application_generator_set( Vec::::with_capacity(callable_context.input_params.len()); for param in &callable_context.input_params { // For intrinsic operations, we assume any parameter can contribute to the output, so if any parameter is - // dynamic the output of the operation is dynamic. + // dynamic the output of the operation is dynamic, unless it is of type `Result`. // When a parameter is bound to a dynamic value, its type contributes to the runtime features used by the // operation application. let runtime_features = derive_runtime_features_for_value_kind_associated_to_type( ValueKind::new_variable_from_type(¶m.ty), ¶m.ty, ); - let value_kind = ValueKind::new_variable_from_type(&callable_context.output_type); + let value_kind = if matches!(callable_context.output_type, Ty::Prim(Prim::Result)) { + ValueKind::Constant + } else { + ValueKind::new_variable_from_type(&callable_context.output_type) + }; let param_compute_kind = ComputeKind::Dynamic { runtime_features, value_kind, @@ -2357,7 +2407,13 @@ fn derive_instrinsic_operation_application_generator_set( Ty::Array(_) => { array_param_application_from_runtime_features(runtime_features, value_kind) } - _ => ParamApplication::Element(param_compute_kind), + _ => ParamApplication::Element(ElemParamApplication { + constant: ComputeKind::Dynamic { + runtime_features: inherent_runtime_features, + value_kind: inherent_value_kind, + }, + variable: param_compute_kind, + }), }; dynamic_param_applications.push(param_application); } diff --git a/source/compiler/qsc_rca/src/cyclic_callables.rs b/source/compiler/qsc_rca/src/cyclic_callables.rs index 625222ca63..39ac53c1db 100644 --- a/source/compiler/qsc_rca/src/cyclic_callables.rs +++ b/source/compiler/qsc_rca/src/cyclic_callables.rs @@ -2,9 +2,9 @@ // Licensed under the MIT License. use crate::{ - ApplicationGeneratorSet, ArrayParamApplication, ComputeKind, ParamApplication, - RuntimeFeatureFlags, ValueKind, common::LocalSpecId, cycle_detection::CycleDetector, - scaffolding::InternalPackageStoreComputeProperties, + ApplicationGeneratorSet, ArrayParamApplication, ComputeKind, ElemParamApplication, + ParamApplication, RuntimeFeatureFlags, ValueKind, common::LocalSpecId, + cycle_detection::CycleDetector, scaffolding::InternalPackageStoreComputeProperties, }; use qsc_fir::{ extensions::InputParam, @@ -151,14 +151,22 @@ impl<'a> Analyzer<'a> { runtime_features: RuntimeFeatureFlags::CallToCyclicFunctionWithDynamicArg, value_kind, }; + let constant_compute_kind = ComputeKind::Dynamic { + runtime_features: RuntimeFeatureFlags::CallToCyclicFunctionWithDynamicArg, + value_kind: ValueKind::Constant, + }; // Create a parameter application depending on the parameter type. let param_application = match ¶m.ty { Ty::Array(_) => ParamApplication::Array(ArrayParamApplication { static_size: param_compute_kind, dynamic_size: param_compute_kind, + constant_content: constant_compute_kind, + }), + _ => ParamApplication::Element(ElemParamApplication { + constant: constant_compute_kind, + variable: param_compute_kind, }), - _ => ParamApplication::Element(param_compute_kind), }; dynamic_param_applications.push(param_application); } @@ -281,6 +289,10 @@ fn create_operation_specialization_application_generator_set( runtime_features: RuntimeFeatureFlags::CyclicOperationSpec, value_kind, }; + let constant_compute_kind = ComputeKind::Dynamic { + runtime_features: RuntimeFeatureFlags::CyclicOperationSpec, + value_kind: ValueKind::Constant, + }; // The compute kind of a cyclic operation for all dynamic parameter applications is the same as its inherent // compute kind. @@ -291,8 +303,12 @@ fn create_operation_specialization_application_generator_set( Ty::Array(_) => ParamApplication::Array(ArrayParamApplication { static_size: inherent_compute_kind, dynamic_size: inherent_compute_kind, + constant_content: constant_compute_kind, + }), + _ => ParamApplication::Element(ElemParamApplication { + constant: constant_compute_kind, + variable: inherent_compute_kind, }), - _ => ParamApplication::Element(inherent_compute_kind), }; dynamic_param_applications.push(param_application); } diff --git a/source/compiler/qsc_rca/src/errors.rs b/source/compiler/qsc_rca/src/errors.rs index 14b9249adf..3aadfc5da1 100644 --- a/source/compiler/qsc_rca/src/errors.rs +++ b/source/compiler/qsc_rca/src/errors.rs @@ -252,6 +252,14 @@ pub enum Error { #[diagnostic(url("https://aka.ms/qdk.qir#use-of-dynamic-generic"))] #[diagnostic(code("Qsc.CapabilitiesCk.UseOfDynamicGeneric"))] UseOfDynamicGeneric(#[label] Span), + + #[error("cannot use a Result literal as output from a dynamic scope")] + #[diagnostic(help( + "using the static Result values `One` and `Zero` as the output of a dynamic branch is not supported by the configured target profile" + ))] + #[diagnostic(url("https://aka.ms/qdk.qir#use-of-static-result-in-variable"))] + #[diagnostic(code("Qsc.CapabilitiesCk.UseOfStaticResultInVariable"))] + UseOfStaticResultInVariable(#[label] Span), } #[must_use] @@ -356,6 +364,9 @@ pub fn generate_errors_from_runtime_features( if runtime_features.contains(RuntimeFeatureFlags::UseOfDynamicGeneric) { errors.push(Error::UseOfDynamicGeneric(span)); } + if runtime_features.contains(RuntimeFeatureFlags::UseOfStaticResultInVariable) { + errors.push(Error::UseOfStaticResultInVariable(span)); + } errors } diff --git a/source/compiler/qsc_rca/src/lib.rs b/source/compiler/qsc_rca/src/lib.rs index 2c1d8770b8..38cbe76320 100644 --- a/source/compiler/qsc_rca/src/lib.rs +++ b/source/compiler/qsc_rca/src/lib.rs @@ -360,8 +360,15 @@ impl ApplicationGeneratorSet { { match param_application { ParamApplication::Element(param_compute_kind) => { - if arg_compute_kind.is_variable_value_kind() { - compute_kind = compute_kind.aggregate(*param_compute_kind); + if let ComputeKind::Dynamic { value_kind, .. } = arg_compute_kind { + match value_kind { + ValueKind::Variable => { + compute_kind = compute_kind.aggregate(param_compute_kind.variable); + } + ValueKind::Constant => { + compute_kind = compute_kind.aggregate(param_compute_kind.constant); + } + } } } ParamApplication::Array(array_param_application) => { @@ -383,7 +390,8 @@ impl ApplicationGeneratorSet { compute_kind.aggregate(array_param_application.static_size); } ValueKind::Constant => { - // No aggregation needed for static arrays. + compute_kind = compute_kind + .aggregate(array_param_application.constant_content); } } } @@ -396,7 +404,7 @@ impl ApplicationGeneratorSet { #[derive(Clone, Debug)] pub enum ParamApplication { - Element(ComputeKind), + Element(ElemParamApplication), Array(ArrayParamApplication), } @@ -412,10 +420,28 @@ impl Display for ParamApplication { } } +#[derive(Clone, Debug)] +pub struct ElemParamApplication { + pub constant: ComputeKind, + pub variable: ComputeKind, +} + +impl Display for ElemParamApplication { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + let mut indent = set_indentation(indented(f), 0); + write!(indent, "ElemParamApplication:")?; + indent = set_indentation(indent, 1); + write!(indent, "\nconstant: {}", self.constant)?; + write!(indent, "\nvariable: {}", self.variable)?; + Ok(()) + } +} + #[derive(Clone, Debug)] pub struct ArrayParamApplication { pub static_size: ComputeKind, pub dynamic_size: ComputeKind, + pub constant_content: ComputeKind, } impl Display for ArrayParamApplication { @@ -425,6 +451,7 @@ impl Display for ArrayParamApplication { indent = set_indentation(indent, 1); write!(indent, "\nstatic_size: {}", self.static_size)?; write!(indent, "\ndynamic_size: {}", self.dynamic_size)?; + write!(indent, "\nconstant_content: {}", self.constant_content)?; Ok(()) } } @@ -601,7 +628,7 @@ bitflags! { /// Runtime features represent anything a program can do that is more complex than executing quantum operations on /// statically allocated qubits and using constant arguments. #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] - pub struct RuntimeFeatureFlags: u32 { + pub struct RuntimeFeatureFlags: u64 { /// Use of a dynamic `Bool`. const UseOfDynamicBool = 1 << 0; /// Use of a dynamic `Int`. @@ -666,6 +693,8 @@ bitflags! { const CallToCustomReset = 1 << 30; /// Use of a dynamic generic parameter. const UseOfDynamicGeneric = 1 << 31; + /// Use of a static `Result` value as a dynamic variable. + const UseOfStaticResultInVariable = 1 << 32; } } @@ -774,7 +803,7 @@ impl RuntimeFeatureFlags { capabilities |= TargetCapabilityFlags::HigherLevelConstructs; } if self.contains(RuntimeFeatureFlags::UseOfDynamicResult) { - capabilities |= TargetCapabilityFlags::HigherLevelConstructs; + capabilities |= TargetCapabilityFlags::StaticSizedArrays; } if self.contains(RuntimeFeatureFlags::UseOfDynamicTuple) { capabilities |= TargetCapabilityFlags::HigherLevelConstructs; @@ -788,6 +817,9 @@ impl RuntimeFeatureFlags { if self.contains(RuntimeFeatureFlags::UseOfDynamicGeneric) { capabilities |= TargetCapabilityFlags::HigherLevelConstructs; } + if self.contains(RuntimeFeatureFlags::UseOfStaticResultInVariable) { + capabilities |= TargetCapabilityFlags::HigherLevelConstructs; + } capabilities } diff --git a/source/compiler/qsc_rca/src/overrider.rs b/source/compiler/qsc_rca/src/overrider.rs index cafad3c691..6193edc75c 100644 --- a/source/compiler/qsc_rca/src/overrider.rs +++ b/source/compiler/qsc_rca/src/overrider.rs @@ -52,6 +52,7 @@ impl<'a> Overrider<'a> { runtime_features: RuntimeFeatureFlags::UseOfDynamicallySizedArray, value_kind: ValueKind::Variable, }, + constant_content: ComputeKind::Static, }, )], }, diff --git a/source/compiler/qsc_rca/src/tests.rs b/source/compiler/qsc_rca/src/tests.rs index 2057229e68..3a78d8f9cc 100644 --- a/source/compiler/qsc_rca/src/tests.rs +++ b/source/compiler/qsc_rca/src/tests.rs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +#![allow(clippy::too_many_lines)] + mod arrays; mod assigns; mod bindings; diff --git a/source/compiler/qsc_rca/src/tests/arrays.rs b/source/compiler/qsc_rca/src/tests/arrays.rs index a3d386fab5..82f6608bd5 100644 --- a/source/compiler/qsc_rca/src/tests/arrays.rs +++ b/source/compiler/qsc_rca/src/tests/arrays.rs @@ -34,7 +34,7 @@ fn check_rca_for_array_with_dynamic_results() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } @@ -89,7 +89,7 @@ fn check_rca_for_array_repeat_with_dynamic_result_value_and_classical_size() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } @@ -179,7 +179,7 @@ fn check_rca_for_mutable_array_statically_appended() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } @@ -522,7 +522,7 @@ fn check_rca_for_array_with_static_size_bound_through_dynamic_tuple() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } diff --git a/source/compiler/qsc_rca/src/tests/assigns.rs b/source/compiler/qsc_rca/src/tests/assigns.rs index cb17e85274..2d2905b870 100644 --- a/source/compiler/qsc_rca/src/tests/assigns.rs +++ b/source/compiler/qsc_rca/src/tests/assigns.rs @@ -42,7 +42,7 @@ fn check_rca_for_dynamic_result_assign_to_local() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } @@ -284,8 +284,8 @@ fn check_rca_for_assign_dynamic_static_mix_call_result_to_tuple_of_vars() { &expect![[r#" ApplicationsGeneratorSet: inherent: Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) - value_kind: Variable + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant dynamic_param_applications: "#]], ); compilation_context.update( @@ -298,8 +298,8 @@ fn check_rca_for_assign_dynamic_static_mix_call_result_to_tuple_of_vars() { &expect![[r#" ApplicationsGeneratorSet: inherent: Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) - value_kind: Variable + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant dynamic_param_applications: "#]], ); } @@ -444,7 +444,7 @@ fn check_rca_for_immutable_dynamic_result_bound_to_dynamic_result() { &expect![[r#" ApplicationsGeneratorSet: inherent: Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | UseOfDynamicResult) + runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | UseOfDynamicResult | UseOfStaticResultInVariable) value_kind: Variable dynamic_param_applications: "#]], ); @@ -472,7 +472,7 @@ fn check_rca_for_immutable_dynamic_result_bound_to_result_from_classical_conditi ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } @@ -500,7 +500,7 @@ fn check_rca_for_immutable_dynamic_result_bound_to_call_with_dynamic_args() { &expect![[r#" ApplicationsGeneratorSet: inherent: Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | UseOfDynamicInt | UseOfDynamicResult) + runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | UseOfDynamicInt | UseOfDynamicResult | UseOfStaticResultInVariable) value_kind: Variable dynamic_param_applications: "#]], ); diff --git a/source/compiler/qsc_rca/src/tests/bindings.rs b/source/compiler/qsc_rca/src/tests/bindings.rs index 1eab2d6ddd..a102525eb2 100644 --- a/source/compiler/qsc_rca/src/tests/bindings.rs +++ b/source/compiler/qsc_rca/src/tests/bindings.rs @@ -40,7 +40,7 @@ fn check_rca_for_immutable_dynamic_result_binding() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } diff --git a/source/compiler/qsc_rca/src/tests/callables.rs b/source/compiler/qsc_rca/src/tests/callables.rs index ad729ef4f1..ef6f787f00 100644 --- a/source/compiler/qsc_rca/src/tests/callables.rs +++ b/source/compiler/qsc_rca/src/tests/callables.rs @@ -19,12 +19,20 @@ fn check_rca_for_function_in_core_package() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | UseOfDynamicInt | UseOfDynamicRange | UseOfDynamicallySizedArray | LoopWithDynamicCondition) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Variable + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | UseOfDynamicInt | UseOfDynamicRange | UseOfDynamicallySizedArray | LoopWithDynamicCondition) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -248,33 +256,49 @@ fn check_rca_for_unrestricted_h() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -292,33 +316,49 @@ fn check_rca_for_base_h() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -336,45 +376,77 @@ fn check_rca_for_unrestricted_r1() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -392,45 +464,77 @@ fn check_rca_for_base_r1() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -448,45 +552,77 @@ fn check_rca_for_unrestricted_rx() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -504,45 +640,77 @@ fn check_rca_for_base_rx() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -560,57 +728,105 @@ fn check_rca_for_unrestricted_rxx() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -628,57 +844,105 @@ fn check_rca_for_base_rxx() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -696,45 +960,77 @@ fn check_rca_for_unrestricted_ry() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -752,45 +1048,77 @@ fn check_rca_for_base_ry() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -808,57 +1136,105 @@ fn check_rca_for_unrestricted_ryy() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -876,57 +1252,105 @@ fn check_rca_for_base_ryy() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -944,45 +1368,77 @@ fn check_rca_for_unrestricted_rz() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1000,45 +1456,77 @@ fn check_rca_for_base_rz() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1056,57 +1544,105 @@ fn check_rca_for_unrestricted_rzz() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1124,57 +1660,105 @@ fn check_rca_for_base_rzz() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1192,33 +1776,49 @@ fn check_rca_for_unrestricted_s() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1236,33 +1836,49 @@ fn check_rca_for_base_s() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1280,33 +1896,49 @@ fn check_rca_for_unrestricted_t() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1324,33 +1956,49 @@ fn check_rca_for_base_t() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1368,33 +2016,49 @@ fn check_rca_for_unrestricted_x() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1412,33 +2076,49 @@ fn check_rca_for_base_x() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1456,33 +2136,49 @@ fn check_rca_for_unrestricted_y() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1500,33 +2196,49 @@ fn check_rca_for_base_y() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1544,33 +2256,49 @@ fn check_rca_for_unrestricted_z() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } @@ -1588,32 +2316,48 @@ fn check_rca_for_base_z() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant ctl-adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant"#]], + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant"#]], ); } diff --git a/source/compiler/qsc_rca/src/tests/cycles.rs b/source/compiler/qsc_rca/src/tests/cycles.rs index a7b24e0fcd..fee5fb64c9 100644 --- a/source/compiler/qsc_rca/src/tests/cycles.rs +++ b/source/compiler/qsc_rca/src/tests/cycles.rs @@ -23,9 +23,13 @@ fn check_rca_for_one_function_cycle() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -54,9 +58,13 @@ fn check_rca_for_two_functions_cycle() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -71,9 +79,13 @@ fn check_rca_for_two_functions_cycle() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -104,9 +116,13 @@ fn check_rca_for_three_functions_cycle() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -120,9 +136,13 @@ fn check_rca_for_three_functions_cycle() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -136,9 +156,13 @@ fn check_rca_for_three_functions_cycle() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -164,9 +188,13 @@ fn check_rca_for_indirect_function_cycle() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -194,9 +222,13 @@ fn check_rca_for_indirect_chain_function_cycle() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -222,9 +254,13 @@ fn check_rca_for_indirect_tuple_function_cycle() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -250,9 +286,13 @@ fn check_rca_for_function_cycle_within_binding() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -279,9 +319,13 @@ fn check_rca_for_function_cycle_within_assignment() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -306,9 +350,13 @@ fn check_rca_for_function_cycle_within_return() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -334,9 +382,13 @@ fn check_rca_for_function_cycle_within_tuple() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -387,9 +439,13 @@ fn check_rca_for_function_cycle_within_call_input() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable [1]: [Parameter Type Array] ArrayParamApplication: static_size: Dynamic: runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) @@ -397,6 +453,9 @@ fn check_rca_for_function_cycle_within_call_input() { dynamic_size: Dynamic: runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) value_kind: Variable + constant_content: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -425,9 +484,13 @@ fn check_rca_for_function_cycle_within_if_block() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -456,9 +519,13 @@ fn check_rca_for_function_cycle_within_if_condition() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -486,9 +553,13 @@ fn check_rca_for_function_cycle_within_for_block() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -516,9 +587,13 @@ fn check_rca_for_function_cycle_within_while_block() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -545,9 +620,13 @@ fn check_rca_for_function_cycle_within_while_condition() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -572,15 +651,27 @@ fn check_rca_for_multi_param_recursive_bool_function() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -605,9 +696,13 @@ fn check_rca_for_multi_param_recursive_unit_function() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant [1]: [Parameter Type Array] ArrayParamApplication: static_size: Dynamic: runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) @@ -615,9 +710,16 @@ fn check_rca_for_multi_param_recursive_unit_function() { dynamic_size: Dynamic: runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) - value_kind: Constant + constant_content: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToCyclicFunctionWithDynamicArg) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -644,9 +746,13 @@ fn check_rca_for_result_recursive_operation() { runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) value_kind: Variable dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -673,18 +779,34 @@ fn check_rca_for_multi_param_result_recursive_operation() { runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) value_kind: Variable dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) - value_kind: Variable - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) - value_kind: Variable - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) - value_kind: Variable - [3]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Variable + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Variable + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Variable + [3]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -711,9 +833,13 @@ fn check_rca_for_operation_body_recursion() { runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -745,17 +871,25 @@ fn check_rca_for_operation_body_adj_recursion() { runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant adj: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant ctl: ctl-adj: "#]], ); @@ -786,18 +920,26 @@ fn check_rca_for_operation_body_ctl_recursion() { runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant adj: ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant ctl-adj: "#]], ); } @@ -827,18 +969,26 @@ fn check_rca_for_operation_multi_controlled_functor_recursion() { runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant adj: ctl: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant ctl-adj: "#]], ); } @@ -863,9 +1013,13 @@ fn check_rca_for_operation_body_recursion_non_unit_return() { runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) value_kind: Variable dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CyclicOperationSpec) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -895,9 +1049,13 @@ fn check_rca_for_operation_body_recursion_preserves_inherent_capabilities() { runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | UseOfDynamicQubit | CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | UseOfDynamicQubit | CallToUnresolvedCallee) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -933,9 +1091,13 @@ fn check_rca_for_two_operation_cycle() { runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -952,9 +1114,13 @@ fn check_rca_for_two_operation_cycle() { runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(CallToUnresolvedCallee) + value_kind: Constant adj: ctl: ctl-adj: "#]], diff --git a/source/compiler/qsc_rca/src/tests/ifs.rs b/source/compiler/qsc_rca/src/tests/ifs.rs index b18d91f414..bf648d7c27 100644 --- a/source/compiler/qsc_rca/src/tests/ifs.rs +++ b/source/compiler/qsc_rca/src/tests/ifs.rs @@ -109,3 +109,53 @@ fn check_rca_for_if_else_expr_with_dynamic_condition_and_classic_branch_blocks() dynamic_param_applications: "#]], ); } + +#[test] +fn check_rca_for_if_else_expr_with_static_result_literal_in_then_block() { + let mut compilation_context = CompilationContext::default(); + compilation_context.update( + r#" + use q = Qubit(); + let r = if M(q) == One { + One + } else { + M(q) + }; + r"#, + ); + let package_store_compute_properties = compilation_context.get_compute_properties(); + check_last_statement_compute_properties( + package_store_compute_properties, + &expect![[r#" + ApplicationsGeneratorSet: + inherent: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | MeasurementWithinDynamicScope | UseOfDynamicResult | UseOfStaticResultInVariable) + value_kind: Variable + dynamic_param_applications: "#]], + ); +} + +#[test] +fn check_rca_for_if_else_expr_with_static_result_literal_in_else_block() { + let mut compilation_context = CompilationContext::default(); + compilation_context.update( + r#" + use q = Qubit(); + let r = if M(q) == One { + M(q) + } else { + Zero + }; + r"#, + ); + let package_store_compute_properties = compilation_context.get_compute_properties(); + check_last_statement_compute_properties( + package_store_compute_properties, + &expect![[r#" + ApplicationsGeneratorSet: + inherent: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | MeasurementWithinDynamicScope | UseOfDynamicResult | UseOfStaticResultInVariable) + value_kind: Variable + dynamic_param_applications: "#]], + ); +} diff --git a/source/compiler/qsc_rca/src/tests/intrinsics.rs b/source/compiler/qsc_rca/src/tests/intrinsics.rs index 166ef6e4d1..60ea41f377 100644 --- a/source/compiler/qsc_rca/src/tests/intrinsics.rs +++ b/source/compiler/qsc_rca/src/tests/intrinsics.rs @@ -38,9 +38,13 @@ fn check_rca_for_quantum_rt_qubit_release() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -59,11 +63,15 @@ fn check_rca_for_quantum_qis_m_body() { body: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -87,6 +95,7 @@ fn check_rca_for_length() { dynamic_size: Dynamic: runtime_features: RuntimeFeatureFlags(UseOfDynamicallySizedArray) value_kind: Variable + constant_content: Static adj: ctl: ctl-adj: "#]], @@ -105,11 +114,15 @@ fn check_rca_for_quantum_qis_mresetz_body() { body: ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -128,9 +141,11 @@ fn check_rca_for_int_as_double() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -149,9 +164,11 @@ fn check_rca_for_int_as_big_int() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -190,9 +207,13 @@ fn check_rca_for_check_zero() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Variable dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Variable + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -211,9 +232,11 @@ fn check_rca_for_message() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -232,9 +255,11 @@ fn check_rca_for_arc_cos() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -253,9 +278,11 @@ fn check_rca_for_arc_sin() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -274,9 +301,11 @@ fn check_rca_for_arc_tan() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -295,12 +324,16 @@ fn check_rca_for_arc_tan_2() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable + [1]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -319,9 +352,11 @@ fn check_rca_for_cos() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -340,9 +375,11 @@ fn check_rca_for_cosh() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -361,9 +398,11 @@ fn check_rca_for_sin() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -382,9 +421,11 @@ fn check_rca_for_sinh() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -403,9 +444,11 @@ fn check_rca_for_tan() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -424,9 +467,11 @@ fn check_rca_for_tanh() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -445,9 +490,11 @@ fn check_rca_for_sqrt() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -466,9 +513,11 @@ fn check_rca_for_log() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -487,9 +536,11 @@ fn check_rca_for_truncate() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -510,15 +561,27 @@ fn check_rca_for_quantum_qis_ccx_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -539,12 +602,20 @@ fn check_rca_for_quantum_qis_cx_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -565,12 +636,20 @@ fn check_rca_for_quantum_qis_cy_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -591,12 +670,20 @@ fn check_rca_for_quantum_qis_cz_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -617,12 +704,20 @@ fn check_rca_for_quantum_qis_rx_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -643,15 +738,27 @@ fn check_rca_for_quantum_qis_rxx_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -672,12 +779,20 @@ fn check_rca_for_quantum_qis_ry_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -698,15 +813,27 @@ fn check_rca_for_quantum_qis_ryy_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -727,12 +854,20 @@ fn check_rca_for_quantum_qis_rz_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -753,15 +888,27 @@ fn check_rca_for_quantum_qis_rzz_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [2]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicDouble) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [2]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -782,9 +929,13 @@ fn check_rca_for_quantum_qis_h_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -805,9 +956,13 @@ fn check_rca_for_quantum_qis_s_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -828,9 +983,13 @@ fn check_rca_for_quantum_qis_s_adj() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -851,9 +1010,13 @@ fn check_rca_for_quantum_qis_sx_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -874,9 +1037,13 @@ fn check_rca_for_quantum_qis_t_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -897,9 +1064,13 @@ fn check_rca_for_quantum_qis_t_adj() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -920,9 +1091,13 @@ fn check_rca_for_quantum_qis_x_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -943,9 +1118,13 @@ fn check_rca_for_quantum_qis_y_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -966,9 +1145,13 @@ fn check_rca_for_quantum_qis_z_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -989,12 +1172,20 @@ fn check_rca_for_quantum_qis_swap_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -1015,9 +1206,13 @@ fn check_rca_for_quantum_qis_reset_body() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -1036,12 +1231,16 @@ fn check_rca_for_begin_estimate_caching() { body: ApplicationsGeneratorSet: inherent: Static dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) - value_kind: Variable + [0]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Variable + [1]: [Parameter Type Element] ElemParamApplication: + constant: Static + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) + value_kind: Variable adj: ctl: ctl-adj: "#]], @@ -1087,9 +1286,16 @@ fn check_rca_for_account_for_estimates_internal() { dynamic_size: Dynamic: runtime_features: RuntimeFeatureFlags(UseOfDynamicInt | UseOfDynamicallySizedArray) value_kind: Constant - [1]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) - value_kind: Constant + constant_content: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + [1]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) + value_kind: Constant [2]: [Parameter Type Array] ArrayParamApplication: static_size: Dynamic: runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit) @@ -1097,6 +1303,9 @@ fn check_rca_for_account_for_estimates_internal() { dynamic_size: Dynamic: runtime_features: RuntimeFeatureFlags(UseOfDynamicQubit | UseOfDynamicallySizedArray) value_kind: Constant + constant_content: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant adj: ctl: ctl-adj: "#]], @@ -1117,9 +1326,13 @@ fn check_rca_for_begin_repeat_estimates_internal() { runtime_features: RuntimeFeatureFlags(0x0) value_kind: Constant dynamic_param_applications: - [0]: [Parameter Type Element] Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) - value_kind: Constant + [0]: [Parameter Type Element] ElemParamApplication: + constant: Dynamic: + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant + variable: Dynamic: + runtime_features: RuntimeFeatureFlags(UseOfDynamicInt) + value_kind: Constant adj: ctl: ctl-adj: "#]], diff --git a/source/compiler/qsc_rca/src/tests/lambdas.rs b/source/compiler/qsc_rca/src/tests/lambdas.rs index e8f36e8b6f..1435c94eb6 100644 --- a/source/compiler/qsc_rca/src/tests/lambdas.rs +++ b/source/compiler/qsc_rca/src/tests/lambdas.rs @@ -191,7 +191,7 @@ fn check_rca_for_operation_lambda_two_parameters() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } diff --git a/source/compiler/qsc_rca/src/tests/measurements.rs b/source/compiler/qsc_rca/src/tests/measurements.rs index 4f80aa7e3b..daa98d6c7e 100644 --- a/source/compiler/qsc_rca/src/tests/measurements.rs +++ b/source/compiler/qsc_rca/src/tests/measurements.rs @@ -19,7 +19,7 @@ fn check_rca_for_static_single_qubit_measurement() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } @@ -64,7 +64,7 @@ fn check_rca_for_static_single_measurement_and_reset() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } @@ -110,7 +110,7 @@ fn check_rca_for_static_multi_qubit_measurement() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } diff --git a/source/compiler/qsc_rca/src/tests/strings.rs b/source/compiler/qsc_rca/src/tests/strings.rs index 0dfbe3f9ee..9efce2c3d1 100644 --- a/source/compiler/qsc_rca/src/tests/strings.rs +++ b/source/compiler/qsc_rca/src/tests/strings.rs @@ -67,7 +67,7 @@ fn check_rca_for_dynamic_interpolated_string() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } @@ -169,8 +169,8 @@ fn check_rca_for_dynamic_string_comparison() { &expect![[r#" ApplicationsGeneratorSet: inherent: Dynamic: - runtime_features: RuntimeFeatureFlags(UseOfDynamicBool | UseOfDynamicString) - value_kind: Variable + runtime_features: RuntimeFeatureFlags(0x0) + value_kind: Constant dynamic_param_applications: "#]], ); } diff --git a/source/compiler/qsc_rca/src/tests/types.rs b/source/compiler/qsc_rca/src/tests/types.rs index e45d5770a0..e30b4d0a71 100644 --- a/source/compiler/qsc_rca/src/tests/types.rs +++ b/source/compiler/qsc_rca/src/tests/types.rs @@ -33,7 +33,7 @@ fn check_rca_for_dynamic_result() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } diff --git a/source/compiler/qsc_rca/src/tests/vars.rs b/source/compiler/qsc_rca/src/tests/vars.rs index 20fcf690b6..dc9f4fb516 100644 --- a/source/compiler/qsc_rca/src/tests/vars.rs +++ b/source/compiler/qsc_rca/src/tests/vars.rs @@ -90,7 +90,7 @@ fn check_rca_for_dynamic_result_var() { ApplicationsGeneratorSet: inherent: Dynamic: runtime_features: RuntimeFeatureFlags(0x0) - value_kind: Variable + value_kind: Constant dynamic_param_applications: "#]], ); } diff --git a/source/qdk_package/tests-integration/resources/adaptive_rifla/output/ArithmeticOps.ll b/source/qdk_package/tests-integration/resources/adaptive_rifla/output/ArithmeticOps.ll index 6a71213f17..910f65b002 100644 --- a/source/qdk_package/tests-integration/resources/adaptive_rifla/output/ArithmeticOps.ll +++ b/source/qdk_package/tests-integration/resources/adaptive_rifla/output/ArithmeticOps.ll @@ -4,6 +4,7 @@ @3 = internal constant [6 x i8] c"3_t2i\00" @4 = internal constant [6 x i8] c"4_t3i\00" @array0 = internal constant [5 x ptr] [ptr inttoptr (i64 0 to ptr), ptr inttoptr (i64 1 to ptr), ptr inttoptr (i64 2 to ptr), ptr inttoptr (i64 3 to ptr), ptr inttoptr (i64 4 to ptr)] +@array1 = internal constant [5 x ptr] [ptr inttoptr (i64 0 to ptr), ptr inttoptr (i64 1 to ptr), ptr inttoptr (i64 2 to ptr), ptr inttoptr (i64 3 to ptr), ptr inttoptr (i64 4 to ptr)] define i64 @ENTRYPOINT__main() #0 { block_0: @@ -12,7 +13,8 @@ block_0: %var_2 = alloca i64 %var_3 = alloca i64 %var_5 = alloca i64 - %var_42 = alloca i64 + %var_11 = alloca i64 + %var_22 = alloca i64 call void @__quantum__rt__initialize(ptr null) store i64 0, ptr %var_0 store i64 0, ptr %var_1 @@ -21,15 +23,15 @@ block_0: store i64 0, ptr %var_5 br label %block_1 block_1: - %var_52 = load i64, ptr %var_5 - %var_6 = icmp slt i64 %var_52, 5 + %var_32 = load i64, ptr %var_5 + %var_6 = icmp slt i64 %var_32, 5 br i1 %var_6, label %block_2, label %block_3 block_2: - %var_102 = load i64, ptr %var_5 - %var_7 = getelementptr ptr, ptr @array0, i64 %var_102 - %var_103 = load ptr, ptr %var_7 - call void @__quantum__qis__x__body(ptr %var_103) - %var_9 = add i64 %var_102, 1 + %var_56 = load i64, ptr %var_5 + %var_7 = getelementptr ptr, ptr @array0, i64 %var_56 + %var_57 = load ptr, ptr %var_7 + call void @__quantum__qis__x__body(ptr %var_57) + %var_9 = add i64 %var_56, 1 store i64 %var_9, ptr %var_5 br label %block_1 block_3: @@ -38,115 +40,62 @@ block_3: call void @__quantum__qis__m__body(ptr inttoptr (i64 2 to ptr), ptr inttoptr (i64 2 to ptr)) call void @__quantum__qis__m__body(ptr inttoptr (i64 3 to ptr), ptr inttoptr (i64 3 to ptr)) call void @__quantum__qis__m__body(ptr inttoptr (i64 4 to ptr), ptr inttoptr (i64 4 to ptr)) - %var_12 = call i1 @__quantum__rt__read_result(ptr inttoptr (i64 0 to ptr)) - br i1 %var_12, label %block_4, label %block_5 + store i64 0, ptr %var_11 + br label %block_4 block_4: - %var_94 = load i64, ptr %var_0 - %var_14 = add i64 %var_94, 1 - store i64 %var_14, ptr %var_0 - %var_96 = load i64, ptr %var_1 - %var_15 = add i64 %var_96, 5 - store i64 %var_15, ptr %var_1 - %var_98 = load i64, ptr %var_2 - %var_16 = sub i64 %var_98, 2 - store i64 %var_16, ptr %var_2 - %var_100 = load i64, ptr %var_3 - %var_17 = mul i64 %var_100, 3 - store i64 %var_17, ptr %var_3 - br label %block_5 + %var_34 = load i64, ptr %var_11 + %var_12 = icmp slt i64 %var_34, 5 + br i1 %var_12, label %block_5, label %block_6 block_5: - %var_18 = call i1 @__quantum__rt__read_result(ptr inttoptr (i64 1 to ptr)) - br i1 %var_18, label %block_6, label %block_7 + %var_44 = load i64, ptr %var_11 + %var_13 = getelementptr ptr, ptr @array1, i64 %var_44 + %var_45 = load ptr, ptr %var_13 + %var_15 = call i1 @__quantum__rt__read_result(ptr %var_45) + br i1 %var_15, label %block_7, label %block_9 block_6: - %var_86 = load i64, ptr %var_0 - %var_20 = add i64 %var_86, 1 - store i64 %var_20, ptr %var_0 - %var_88 = load i64, ptr %var_1 - %var_21 = add i64 %var_88, 5 - store i64 %var_21, ptr %var_1 - %var_90 = load i64, ptr %var_2 - %var_22 = sub i64 %var_90, 2 - store i64 %var_22, ptr %var_2 - %var_92 = load i64, ptr %var_3 - %var_23 = mul i64 %var_92, 3 - store i64 %var_23, ptr %var_3 - br label %block_7 + store i64 0, ptr %var_22 + br label %block_8 block_7: - %var_24 = call i1 @__quantum__rt__read_result(ptr inttoptr (i64 2 to ptr)) - br i1 %var_24, label %block_8, label %block_9 -block_8: - %var_78 = load i64, ptr %var_0 - %var_26 = add i64 %var_78, 1 - store i64 %var_26, ptr %var_0 - %var_80 = load i64, ptr %var_1 - %var_27 = add i64 %var_80, 5 - store i64 %var_27, ptr %var_1 - %var_82 = load i64, ptr %var_2 - %var_28 = sub i64 %var_82, 2 - store i64 %var_28, ptr %var_2 - %var_84 = load i64, ptr %var_3 - %var_29 = mul i64 %var_84, 3 - store i64 %var_29, ptr %var_3 + %var_48 = load i64, ptr %var_0 + %var_17 = add i64 %var_48, 1 + store i64 %var_17, ptr %var_0 + %var_50 = load i64, ptr %var_1 + %var_18 = add i64 %var_50, 5 + store i64 %var_18, ptr %var_1 + %var_52 = load i64, ptr %var_2 + %var_19 = sub i64 %var_52, 2 + store i64 %var_19, ptr %var_2 + %var_54 = load i64, ptr %var_3 + %var_20 = mul i64 %var_54, 3 + store i64 %var_20, ptr %var_3 br label %block_9 +block_8: + %var_36 = load i64, ptr %var_22 + %var_23 = icmp slt i64 %var_36, 5 + br i1 %var_23, label %block_10, label %block_11 block_9: - %var_30 = call i1 @__quantum__rt__read_result(ptr inttoptr (i64 3 to ptr)) - br i1 %var_30, label %block_10, label %block_11 + %var_46 = load i64, ptr %var_11 + %var_21 = add i64 %var_46, 1 + store i64 %var_21, ptr %var_11 + br label %block_4 block_10: - %var_70 = load i64, ptr %var_0 - %var_32 = add i64 %var_70, 1 - store i64 %var_32, ptr %var_0 - %var_72 = load i64, ptr %var_1 - %var_33 = add i64 %var_72, 5 - store i64 %var_33, ptr %var_1 - %var_74 = load i64, ptr %var_2 - %var_34 = sub i64 %var_74, 2 - store i64 %var_34, ptr %var_2 - %var_76 = load i64, ptr %var_3 - %var_35 = mul i64 %var_76, 3 - store i64 %var_35, ptr %var_3 - br label %block_11 + %var_41 = load i64, ptr %var_22 + %var_24 = getelementptr ptr, ptr @array0, i64 %var_41 + %var_42 = load ptr, ptr %var_24 + call void @__quantum__qis__reset__body(ptr %var_42) + %var_26 = add i64 %var_41, 1 + store i64 %var_26, ptr %var_22 + br label %block_8 block_11: - %var_36 = call i1 @__quantum__rt__read_result(ptr inttoptr (i64 4 to ptr)) - br i1 %var_36, label %block_12, label %block_13 -block_12: - %var_62 = load i64, ptr %var_0 - %var_38 = add i64 %var_62, 1 - store i64 %var_38, ptr %var_0 - %var_64 = load i64, ptr %var_1 - %var_39 = add i64 %var_64, 5 - store i64 %var_39, ptr %var_1 - %var_66 = load i64, ptr %var_2 - %var_40 = sub i64 %var_66, 2 - store i64 %var_40, ptr %var_2 - %var_68 = load i64, ptr %var_3 - %var_41 = mul i64 %var_68, 3 - store i64 %var_41, ptr %var_3 - br label %block_13 -block_13: - store i64 0, ptr %var_42 - br label %block_14 -block_14: - %var_54 = load i64, ptr %var_42 - %var_43 = icmp slt i64 %var_54, 5 - br i1 %var_43, label %block_15, label %block_16 -block_15: - %var_59 = load i64, ptr %var_42 - %var_44 = getelementptr ptr, ptr @array0, i64 %var_59 - %var_60 = load ptr, ptr %var_44 - call void @__quantum__qis__reset__body(ptr %var_60) - %var_46 = add i64 %var_59, 1 - store i64 %var_46, ptr %var_42 - br label %block_14 -block_16: call void @__quantum__rt__tuple_record_output(i64 4, ptr @0) - %var_55 = load i64, ptr %var_0 - call void @__quantum__rt__int_record_output(i64 %var_55, ptr @1) - %var_56 = load i64, ptr %var_1 - call void @__quantum__rt__int_record_output(i64 %var_56, ptr @2) - %var_57 = load i64, ptr %var_2 - call void @__quantum__rt__int_record_output(i64 %var_57, ptr @3) - %var_58 = load i64, ptr %var_3 - call void @__quantum__rt__int_record_output(i64 %var_58, ptr @4) + %var_37 = load i64, ptr %var_0 + call void @__quantum__rt__int_record_output(i64 %var_37, ptr @1) + %var_38 = load i64, ptr %var_1 + call void @__quantum__rt__int_record_output(i64 %var_38, ptr @2) + %var_39 = load i64, ptr %var_2 + call void @__quantum__rt__int_record_output(i64 %var_39, ptr @3) + %var_40 = load i64, ptr %var_3 + call void @__quantum__rt__int_record_output(i64 %var_40, ptr @4) ret i64 0 } diff --git a/source/qdk_package/tests-integration/resources/adaptive_rifla/output/SwitchHandling.ll b/source/qdk_package/tests-integration/resources/adaptive_rifla/output/SwitchHandling.ll index 688c300c4e..944df245fc 100644 --- a/source/qdk_package/tests-integration/resources/adaptive_rifla/output/SwitchHandling.ll +++ b/source/qdk_package/tests-integration/resources/adaptive_rifla/output/SwitchHandling.ll @@ -1,95 +1,103 @@ @0 = internal constant [4 x i8] c"0_r\00" @array0 = internal constant [2 x ptr] [ptr inttoptr (i64 0 to ptr), ptr inttoptr (i64 1 to ptr)] +@array1 = internal constant [2 x ptr] [ptr inttoptr (i64 0 to ptr), ptr inttoptr (i64 1 to ptr)] define i64 @ENTRYPOINT__main() #0 { block_0: %var_1 = alloca i64 %var_6 = alloca i64 - %var_16 = alloca i64 + %var_8 = alloca i64 + %var_17 = alloca i64 call void @__quantum__rt__initialize(ptr null) store i64 0, ptr %var_1 br label %block_1 block_1: - %var_25 = load i64, ptr %var_1 - %var_2 = icmp slt i64 %var_25, 2 + %var_26 = load i64, ptr %var_1 + %var_2 = icmp slt i64 %var_26, 2 br i1 %var_2, label %block_2, label %block_3 block_2: - %var_42 = load i64, ptr %var_1 - %var_3 = getelementptr ptr, ptr @array0, i64 %var_42 - %var_43 = load ptr, ptr %var_3 - call void @__quantum__qis__x__body(ptr %var_43) - %var_5 = add i64 %var_42, 1 + %var_46 = load i64, ptr %var_1 + %var_3 = getelementptr ptr, ptr @array0, i64 %var_46 + %var_47 = load ptr, ptr %var_3 + call void @__quantum__qis__x__body(ptr %var_47) + %var_5 = add i64 %var_46, 1 store i64 %var_5, ptr %var_1 br label %block_1 block_3: store i64 0, ptr %var_6 call void @__quantum__qis__m__body(ptr inttoptr (i64 0 to ptr), ptr inttoptr (i64 0 to ptr)) call void @__quantum__qis__m__body(ptr inttoptr (i64 1 to ptr), ptr inttoptr (i64 1 to ptr)) - store i64 0, ptr %var_6 - %var_9 = call i1 @__quantum__rt__read_result(ptr inttoptr (i64 0 to ptr)) - br i1 %var_9, label %block_4, label %block_5 + store i64 0, ptr %var_8 + br label %block_4 block_4: - %var_40 = load i64, ptr %var_6 - %var_11 = add i64 %var_40, 1 - store i64 %var_11, ptr %var_6 - br label %block_5 + %var_29 = load i64, ptr %var_8 + %var_9 = icmp slt i64 %var_29, 2 + br i1 %var_9, label %block_5, label %block_6 block_5: - %var_28 = load i64, ptr %var_6 - %var_12 = shl i64 %var_28, 1 + %var_38 = load i64, ptr %var_8 + %var_10 = getelementptr ptr, ptr @array1, i64 %var_38 + %var_39 = load ptr, ptr %var_10 + %var_40 = load i64, ptr %var_6 + %var_12 = shl i64 %var_40, 1 store i64 %var_12, ptr %var_6 - %var_13 = call i1 @__quantum__rt__read_result(ptr inttoptr (i64 1 to ptr)) - br i1 %var_13, label %block_6, label %block_7 + %var_13 = call i1 @__quantum__rt__read_result(ptr %var_39) + br i1 %var_13, label %block_7, label %block_9 block_6: - %var_38 = load i64, ptr %var_6 - %var_15 = add i64 %var_38, 1 - store i64 %var_15, ptr %var_6 - br label %block_7 -block_7: - store i64 0, ptr %var_16 + store i64 0, ptr %var_17 br label %block_8 +block_7: + %var_44 = load i64, ptr %var_6 + %var_15 = add i64 %var_44, 1 + store i64 %var_15, ptr %var_6 + br label %block_9 block_8: - %var_31 = load i64, ptr %var_16 - %var_17 = icmp slt i64 %var_31, 2 - br i1 %var_17, label %block_9, label %block_10 + %var_31 = load i64, ptr %var_17 + %var_18 = icmp slt i64 %var_31, 2 + br i1 %var_18, label %block_10, label %block_11 block_9: - %var_35 = load i64, ptr %var_16 - %var_18 = getelementptr ptr, ptr @array0, i64 %var_35 - %var_36 = load ptr, ptr %var_18 + %var_42 = load i64, ptr %var_8 + %var_16 = add i64 %var_42, 1 + store i64 %var_16, ptr %var_8 + br label %block_4 +block_10: + %var_35 = load i64, ptr %var_17 + %var_19 = getelementptr ptr, ptr @array0, i64 %var_35 + %var_36 = load ptr, ptr %var_19 call void @__quantum__qis__reset__body(ptr %var_36) - %var_20 = add i64 %var_35, 1 - store i64 %var_20, ptr %var_16 + %var_21 = add i64 %var_35, 1 + store i64 %var_21, ptr %var_17 br label %block_8 -block_10: - %var_32 = load i64, ptr %var_6 - %var_21 = icmp eq i64 %var_32, 0 - br i1 %var_21, label %block_11, label %block_12 block_11: - br label %block_13 + %var_32 = load i64, ptr %var_6 + %var_22 = icmp eq i64 %var_32, 0 + br i1 %var_22, label %block_12, label %block_13 block_12: - %var_33 = load i64, ptr %var_6 - %var_22 = icmp eq i64 %var_33, 1 - br i1 %var_22, label %block_14, label %block_15 + br label %block_14 block_13: + %var_33 = load i64, ptr %var_6 + %var_23 = icmp eq i64 %var_33, 1 + br i1 %var_23, label %block_15, label %block_16 +block_14: call void @__quantum__qis__mresetz__body(ptr inttoptr (i64 2 to ptr), ptr inttoptr (i64 2 to ptr)) call void @__quantum__rt__result_record_output(ptr inttoptr (i64 2 to ptr), ptr @0) ret i64 0 -block_14: - call void @__quantum__qis__ry__body(double 3.141592653589793, ptr inttoptr (i64 2 to ptr)) - br label %block_16 block_15: - %var_34 = load i64, ptr %var_6 - %var_23 = icmp eq i64 %var_34, 2 - br i1 %var_23, label %block_17, label %block_18 + call void @__quantum__qis__ry__body(double 3.141592653589793, ptr inttoptr (i64 2 to ptr)) + br label %block_17 block_16: - br label %block_13 + %var_34 = load i64, ptr %var_6 + %var_24 = icmp eq i64 %var_34, 2 + br i1 %var_24, label %block_18, label %block_19 block_17: - call void @__quantum__qis__rz__body(double 3.141592653589793, ptr inttoptr (i64 2 to ptr)) - br label %block_19 + br label %block_14 block_18: - call void @__quantum__qis__rx__body(double 3.141592653589793, ptr inttoptr (i64 2 to ptr)) - br label %block_19 + call void @__quantum__qis__rz__body(double 3.141592653589793, ptr inttoptr (i64 2 to ptr)) + br label %block_20 block_19: - br label %block_16 + call void @__quantum__qis__rx__body(double 3.141592653589793, ptr inttoptr (i64 2 to ptr)) + br label %block_20 +block_20: + br label %block_17 } declare void @__quantum__rt__initialize(ptr) From fc3d7654e0de5932bd1e62867d0d348feab70a13 Mon Sep 17 00:00:00 2001 From: "Stefan J. Wernli" Date: Mon, 1 Jun 2026 15:50:04 -0700 Subject: [PATCH 2/4] Fix lint --- source/compiler/qsc_partial_eval/src/tests.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/compiler/qsc_partial_eval/src/tests.rs b/source/compiler/qsc_partial_eval/src/tests.rs index 08e66af366..ac8d3adfda 100644 --- a/source/compiler/qsc_partial_eval/src/tests.rs +++ b/source/compiler/qsc_partial_eval/src/tests.rs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +#![allow(clippy::too_many_lines)] + mod arrays; mod assigns; mod bindings; From c157337b365ab6f5ea4e96ca5cd6783e9efb971a Mon Sep 17 00:00:00 2001 From: "Stefan J. Wernli" Date: Mon, 1 Jun 2026 22:36:40 -0700 Subject: [PATCH 3/4] use helper function --- source/compiler/qsc_rca/src/core.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/source/compiler/qsc_rca/src/core.rs b/source/compiler/qsc_rca/src/core.rs index a7823833e3..855a37b951 100644 --- a/source/compiler/qsc_rca/src/core.rs +++ b/source/compiler/qsc_rca/src/core.rs @@ -1208,10 +1208,7 @@ impl<'a> Analyzer<'a> { // If the condition is dynamic, we may require an additional runtime feature. if let ComputeKind::Dynamic { value_kind, .. } = condition_expr_compute_kind - && (value_kind == ValueKind::Variable - || self - .target_capabilities - .contains(TargetCapabilityFlags::BackwardsBranching)) + && (value_kind == ValueKind::Variable || self.should_emit_classical_loops()) { let ComputeKind::Dynamic { runtime_features, .. From 93e1704ff60702b15dd77f78dab3149ee5b1ff4e Mon Sep 17 00:00:00 2001 From: "Stefan J. Wernli" Date: Tue, 2 Jun 2026 09:48:41 -0700 Subject: [PATCH 4/4] gracefully fail --- source/compiler/qsc_partial_eval/src/lib.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/source/compiler/qsc_partial_eval/src/lib.rs b/source/compiler/qsc_partial_eval/src/lib.rs index e2c328bb9f..fc387d8f86 100644 --- a/source/compiler/qsc_partial_eval/src/lib.rs +++ b/source/compiler/qsc_partial_eval/src/lib.rs @@ -2528,6 +2528,11 @@ impl<'a> PartialEvaluator<'a> { .push(jump_to_continuation_ins); let _ = self.eval_context.pop_block_node(); return Ok(EvalControlFlow::Continue(Value::unit())); + } else if let Value::Bool(true) = condition_value { + return Err(Error::Unexpected( + "loop with constant true condition".to_string(), + self.get_expr_package_span(condition_expr_id), + )); } // Otherwise, branch to either the body block or the continuation block.