Fix cphase gate argument order and fix 4 QASM-to-Q# compiler bugs (#3158)

The `cphase` OpenQASM compatibility gate fails with type errors because
its Q# signature has the control qubit before the angle parameter, while
the compiler always emits classical args before qubit args (as with
every other gate).

```
type error: expected Qubit, found Angle
type error: expected Angle, found Qubit
```

- Reordered `cphase` parameters from `(ctrl : Qubit, lambda : Angle,
qubit : Qubit)` to `(lambda : Angle, ctrl : Qubit, qubit : Qubit)` in
`Std.OpenQASM.Intrinsic`, consistent with `cp`, `crx`, `cry`, `crz`, and
`cu`
- Body unchanged — it references params by name
- Added comprehensive test `all_stdgates_inc_gates_can_be_called` that
calls every gate from OpenQASM's `stdgates.inc` in a single test (25
main gates + 7 backwards compatibility gates: `CX`, `phase`, `cphase`,
`id`, `u1`, `u2`, `u3`)
- Added test `all_stdgates_inc_gates_adjoint_can_be_called` that calls
the adjoint (`inv @`) of every stdgates.inc gate
- Added test `all_stdgates_inc_gates_controlled_can_be_called` that
calls the singly controlled (`ctrl @`) version of every stdgates.inc
gate
- Added Q# compilation verification to all QASM-to-Q# test helpers
(`compile_qasm_to_qsharp`, `compile_qasm_stmt_to_qsharp_with_semantics`,
`compile_qasm_to_qsharp_file`, `compile_qasm_to_qsharp_operation`,
`qsharp_from_qasm_compilation`) so that generated Q# is verified through
the Q# compiler via `compile_ast`. For File mode packages the AST is
verified directly; for Fragments/Operation mode the QASM source is
re-compiled as File mode to produce a complete Q# structure before
verification.
- Fixed `__AngleShl__` → `AngleShl` typo in compiler binary operator
name mapping (the Q# library function is `AngleShl`, matching
`AngleShr`, `AngleAndB`, etc.)
- Fixed `negctrl` functor constraints: `ApplyControlledOnInt` requires
`Adj + Ctl` (it uses a `within/apply` pattern internally), but the
constraint solver only marked `Ctl` for `negctrl`. Split `Ctrl` and
`NegCtrl` handling in `functor_constraints.rs` so that `NegCtrl` sets
both `requires_adj` and `requires_ctl`.
- Fixed `bit` ordered comparison operators (`>`, `>=`, `<`, `<=`): Q#
`Result` type only supports `==` and `!=`. The compiler now wraps both
operands in `ResultAsInt()` calls for ordered comparisons, matching how
`bit[]` comparisons already use `ResultArrayAsIntBE`.
- Fixed `input` variable mutation: OpenQASM `input` variables are
mutable, but Q# operation parameters are immutable. Added a
`collect_assigned_input_symbols` pre-analysis pass that identifies which
input params are reassigned in the program, then generates `mutable a =
a;` shadow copies at the start of the operation body for only those
parameters.
- Fixed `return_from_switch` test: the original QASM input was invalid
(a function returning `bit` with a switch that didn't cover all cases).
Added a `default { return 0; }` branch to make the test input valid.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: minestarks <16928427+minestarks@users.noreply.github.com>
Co-authored-by: idavis <63540+idavis@users.noreply.github.com>

Author: 3 people

library/std/src/Std/OpenQASM/Intrinsic.qs

@@ -222,7 +222,7 @@ operation phase(lambda : Angle, qubit : Qubit) : Unit is Adj + Ctl {
     U(ZERO_ANGLE(), ZERO_ANGLE(), lambda, qubit);
 }
 
-operation cphase(ctrl : Qubit, lambda : Angle, qubit : Qubit) : Unit is Adj + Ctl {
+operation cphase(lambda : Angle, ctrl : Qubit, qubit : Qubit) : Unit is Adj + Ctl {
     Controlled phase([ctrl], (lambda, qubit));
 }
 

source/compiler/qsc_openqasm_compiler/src/compiler.rs

@@ -9,7 +9,7 @@ use std::{rc::Rc, str::FromStr, sync::Arc};
 use error::CompilerErrorKind;
 use num_bigint::BigInt;
 use qsc_data_structures::{error::WithSource, source::SourceMap, span::Span, target::Profile};
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::{
     CompilerConfig, FunctorConstraintSolver, FunctorConstraints, OperationSignature,
@@ -52,6 +52,7 @@ use qsc_openqasm_parser::{
         },
         symbols::{IOKind, Symbol, SymbolId, SymbolTable},
         types::{Type, promote_types},
+        visit::{Visitor, walk_stmt},
     },
     stdlib::complex::Complex,
 };
@@ -108,6 +109,7 @@ pub fn compile_to_qsharp_ast_with_config(
         errors,
         pragma_config: PragmaConfig::default(),
         functor_constraints: FxHashMap::default(),
+        assigned_input_symbols: FxHashSet::default(),
     };
 
     compiler.compile(&program)
@@ -182,6 +184,56 @@ pub struct QasmCompiler {
     /// Functor constraints for each gate, computed by the constraint solver pass.
     /// Maps gate symbol IDs to their required functor support (Adj, Ctl).
     pub functor_constraints: FxHashMap<SymbolId, FunctorConstraints>,
+    /// Set of input symbol names that are targets of assignment statements.
+    /// Used to create mutable shadow copies for these parameters in the operation body.
+    pub assigned_input_symbols: FxHashSet<String>,
+}
+
+/// Collects the names of input symbols that are assigned to in the program.
+/// This is used to determine which input parameters need mutable shadow copies
+/// in the generated Q# operation body.
+fn collect_assigned_input_symbols(
+    program: &semast::Program,
+    symbols: &SymbolTable,
+) -> FxHashSet<String> {
+    struct AssignmentCollector<'a> {
+        input_names: &'a FxHashSet<String>,
+        symbols: &'a SymbolTable,
+        assigned: FxHashSet<String>,
+    }
+
+    impl Visitor for AssignmentCollector<'_> {
+        fn visit_stmt(&mut self, stmt: &semast::Stmt) {
+            if let semast::StmtKind::Assign(assign) = &*stmt.kind
+                && let semast::ExprKind::Ident(sym_id) = &*assign.lhs.kind
+            {
+                let sym = &self.symbols[*sym_id];
+                if self.input_names.contains(&sym.name) {
+                    self.assigned.insert(sym.name.clone());
+                }
+            }
+            walk_stmt(self, stmt);
+        }
+    }
+
+    let input_names: FxHashSet<String> = symbols
+        .get_input()
+        .unwrap_or_default()
+        .iter()
+        .map(|s| s.name.clone())
+        .collect();
+
+    if input_names.is_empty() {
+        return FxHashSet::default();
+    }
+
+    let mut collector = AssignmentCollector {
+        input_names: &input_names,
+        symbols,
+        assigned: FxHashSet::default(),
+    };
+    collector.visit_program(program);
+    collector.assigned
 }
 
 impl QasmCompiler {
@@ -194,6 +246,10 @@ impl QasmCompiler {
         // each gate definition needs to support based on how they're called.
         self.functor_constraints = FunctorConstraintSolver::solve(program);
 
+        // Collect input symbols that are targets of assignment statements.
+        // These need mutable shadow copies when compiled as operation parameters.
+        self.assigned_input_symbols = collect_assigned_input_symbols(program, &self.symbols);
+
         // in non-file mode we need the runtime imports in the body
         let program_ty = self.config.program_ty.clone();
 
@@ -385,6 +441,22 @@ impl QasmCompiler {
                 })
                 .collect::<Vec<_>>();
             let mut validation_stmts = Self::get_argument_validation_stmts(&args);
+
+            // In OpenQASM, input variables are mutable. In Q#, operation parameters
+            // are immutable. Create mutable shadow copies for input params that
+            // are reassigned in the program body so that `set` works correctly.
+            for s in input {
+                if self.assigned_input_symbols.contains(&s.name) {
+                    let qsharp_ty = self.map_semantic_type_to_qsharp_type(&s.ty, s.ty_span);
+                    let init_expr = build_path_ident_expr(&s.name, s.span, s.span);
+                    let shadow_stmt = build_classical_decl(
+                        &s.name, false, // mutable
+                        s.ty_span, s.span, s.span, &qsharp_ty, init_expr,
+                    );
+                    validation_stmts.push(shadow_stmt);
+                }
+            }
+
             validation_stmts.extend(stmts);
             stmts = validation_stmts;
         }
@@ -1770,6 +1842,21 @@ impl QasmCompiler {
             return Self::compile_complex_binary_op(op, lhs, rhs);
         }
 
+        // Q# Result type only supports == and !=. For ordered comparisons
+        // (>, >=, <, <=) on bit values, convert to Int first.
+        if matches!(&binary.lhs.ty, Type::Bit(..))
+            && matches!(&binary.rhs.ty, Type::Bit(..))
+            && matches!(
+                op,
+                qsast::BinOp::Gt | qsast::BinOp::Gte | qsast::BinOp::Lt | qsast::BinOp::Lte
+            )
+        {
+            let span = binary.span();
+            let lhs = build_qasm_convert_call_with_one_param("ResultAsInt", lhs, span, span);
+            let rhs = build_qasm_convert_call_with_one_param("ResultAsInt", rhs, span, span);
+            return build_binary_expr(false, op, lhs, rhs, span);
+        }
+
         let is_assignment = false;
         build_binary_expr(is_assignment, op, lhs, rhs, binary.span())
     }
@@ -1791,7 +1878,7 @@ impl QasmCompiler {
 
         let fn_name: &str = match op {
             // Bit shift
-            qsast::BinOp::Shl => "__AngleShl__",
+            qsast::BinOp::Shl => "AngleShl",
             qsast::BinOp::Shr => "AngleShr",
 
             // Bitwise

source/compiler/qsc_openqasm_compiler/src/functor_constraints.rs

@@ -194,7 +194,13 @@ impl Visitor for PropagationVisitor<'_> {
                     GateModifierKind::Inv => {
                         new_constraints.requires_adj = true;
                     }
-                    GateModifierKind::Ctrl(_) | GateModifierKind::NegCtrl(_) => {
+                    GateModifierKind::Ctrl(_) => {
+                        new_constraints.requires_ctl = true;
+                    }
+                    GateModifierKind::NegCtrl(_) => {
+                        // The negctrl modifier uses ApplyControlledOnInt which requires
+                        // Adj + Ctl because it uses a within/apply pattern internally.
+                        new_constraints.requires_adj = true;
                         new_constraints.requires_ctl = true;
                     }
                     GateModifierKind::Pow(_) => {
@@ -231,7 +237,13 @@ impl Visitor for FunctorConstraintSolver {
                 GateModifierKind::Inv => {
                     call_constraints.requires_adj = true;
                 }
-                GateModifierKind::Ctrl(_) | GateModifierKind::NegCtrl(_) => {
+                GateModifierKind::Ctrl(_) => {
+                    call_constraints.requires_ctl = true;
+                }
+                GateModifierKind::NegCtrl(_) => {
+                    // The negctrl modifier uses ApplyControlledOnInt which requires
+                    // Adj + Ctl because it uses a within/apply pattern internally.
+                    call_constraints.requires_adj = true;
                     call_constraints.requires_ctl = true;
                 }
                 GateModifierKind::Pow(_) => {

source/compiler/qsc_openqasm_compiler/src/tests.rs

@@ -20,7 +20,7 @@ use qsc_hir::hir::PackageId;
 use qsc_openqasm_parser::io::{InMemorySourceResolver, SourceResolver};
 use qsc_openqasm_parser::semantic::{QasmSemanticParseResult, parse_source};
 use qsc_passes::PackageType;
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 use std::sync::Arc;
 
 pub(crate) mod assignment;
@@ -110,6 +110,7 @@ fn compile_with_config<S: Into<Arc<str>>>(
         errors,
         pragma_config: PragmaConfig::default(),
         functor_constraints: FxHashMap::default(),
+        assigned_input_symbols: FxHashSet::default(),
     };
 
     let unit = compiler.compile(&program);
@@ -176,6 +177,7 @@ pub fn compile_all_with_config<P: Into<Arc<str>>>(
         errors,
         pragma_config: PragmaConfig::default(),
         functor_constraints: FxHashMap::default(),
+        assigned_input_symbols: FxHashSet::default(),
     };
 
     let unit = compiler.compile(&program);
@@ -285,6 +287,7 @@ pub(crate) fn parse_all<P: Into<Arc<str>>>(
 pub fn compile_qasm_to_qsharp_file<S: Into<Arc<str>>>(
     source: S,
 ) -> miette::Result<String, Vec<Report>> {
+    let source: Arc<str> = source.into();
     let config = CompilerConfig::new(
         QubitSemantics::Qiskit,
         OutputSemantics::OpenQasm,
@@ -293,30 +296,27 @@ pub fn compile_qasm_to_qsharp_file<S: Into<Arc<str>>>(
         None,
     );
     let unit = compile_with_config(source, config)?;
-    if unit.has_errors() {
-        let errors = unit.errors.into_iter().map(Report::new).collect();
-        return Err(errors);
-    }
-    let qsharp = gen_qsharp(&unit.package);
-    Ok(qsharp)
+    qsharp_from_qasm_compilation(unit)
 }
 
 pub fn compile_qasm_to_qsharp_operation<S: Into<Arc<str>>>(
     source: S,
 ) -> miette::Result<String, Vec<Report>> {
+    let source: Arc<str> = source.into();
     let config = CompilerConfig::new(
         QubitSemantics::Qiskit,
         OutputSemantics::OpenQasm,
         ProgramType::Operation,
         Some("Test".into()),
         None,
     );
-    let unit = compile_with_config(source, config)?;
+    let unit = compile_with_config(source.clone(), config)?;
     if unit.has_errors() {
         let errors = unit.errors.into_iter().map(Report::new).collect();
         return Err(errors);
     }
     let qsharp = gen_qsharp(&unit.package);
+    verify_qsharp_from_qasm_source(source, QubitSemantics::Qiskit)?;
     Ok(qsharp)
 }
 
@@ -360,15 +360,22 @@ pub fn compile_qasm_to_qsharp_with_semantics<S: Into<Arc<str>>>(
     source: S,
     qubit_semantics: QubitSemantics,
 ) -> miette::Result<String, Vec<Report>> {
+    let source: Arc<str> = source.into();
     let config = CompilerConfig::new(
         qubit_semantics,
         OutputSemantics::Qiskit,
         ProgramType::Fragments,
         None,
         None,
     );
-    let unit = compile_with_config(source, config)?;
-    qsharp_from_qasm_compilation(unit)
+    let unit = compile_with_config(source.clone(), config)?;
+    if unit.has_errors() {
+        let errors = unit.errors.into_iter().map(Report::new).collect();
+        return Err(errors);
+    }
+    let qsharp = gen_qsharp(&unit.package);
+    verify_qsharp_from_qasm_source(source, qubit_semantics)?;
+    Ok(qsharp)
 }
 
 pub fn qsharp_from_qasm_compilation(unit: QasmCompileUnit) -> miette::Result<String, Vec<Report>> {
@@ -377,9 +384,54 @@ pub fn qsharp_from_qasm_compilation(unit: QasmCompileUnit) -> miette::Result<Str
         return Err(errors);
     }
     let qsharp = gen_qsharp(&unit.package);
+    verify_qsharp_ast(&unit)?;
     Ok(qsharp)
 }
 
+/// Verifies that QASM source produces valid Q# by re-compiling it in File mode
+/// (which produces a complete Q# program) and passing the result through the Q#
+/// compiler. This is used for fragments mode where the Q# AST has top-level
+/// statements that the Q# compiler cannot process directly.
+fn verify_qsharp_from_qasm_source(
+    source: Arc<str>,
+    qubit_semantics: QubitSemantics,
+) -> miette::Result<(), Vec<Report>> {
+    let config = CompilerConfig::new(
+        qubit_semantics,
+        OutputSemantics::OpenQasm,
+        ProgramType::File,
+        Some("Test".into()),
+        None,
+    );
+    let file_unit = compile_with_config(source, config)?;
+    if file_unit.has_errors() {
+        let errors = file_unit.errors.into_iter().map(Report::new).collect();
+        return Err(errors);
+    }
+    verify_qsharp_ast(&file_unit)
+}
+
+/// Verifies a Q# AST package (with namespaces) compiles through the Q# compiler.
+fn verify_qsharp_ast(unit: &QasmCompileUnit) -> miette::Result<(), Vec<Report>> {
+    let capabilities = unit.profile.into();
+    let (stdid, store) = package_store_with_stdlib(capabilities);
+    let dependencies = vec![(PackageId::CORE, None), (stdid, None)];
+    let (_compiled, errors) = compile_ast(
+        &store,
+        &dependencies,
+        unit.package.clone(),
+        unit.source_map.clone(),
+        PackageType::Lib,
+        capabilities,
+    );
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        let reports = errors.into_iter().map(Report::new).collect();
+        Err(reports)
+    }
+}
+
 pub fn compile_qasm_stmt_to_qsharp<S: Into<Arc<str>>>(
     source: S,
 ) -> miette::Result<String, Vec<Report>> {
@@ -390,18 +442,20 @@ pub fn compile_qasm_stmt_to_qsharp_with_semantics<S: Into<Arc<str>>>(
     source: S,
     qubit_semantics: QubitSemantics,
 ) -> miette::Result<String, Vec<Report>> {
+    let source: Arc<str> = source.into();
     let config = CompilerConfig::new(
         qubit_semantics,
         OutputSemantics::Qiskit,
         ProgramType::Fragments,
         None,
         None,
     );
-    let unit = compile_with_config(source, config)?;
+    let unit = compile_with_config(source.clone(), config)?;
     if unit.has_errors() {
         let errors = unit.errors.into_iter().map(Report::new).collect();
         return Err(errors);
     }
+    verify_qsharp_from_qasm_source(source, qubit_semantics)?;
     let qsharp = get_last_statement_as_qsharp(&unit.package);
     Ok(qsharp)
 }

source/compiler/qsc_openqasm_compiler/src/tests/assignment.rs

@@ -187,7 +187,7 @@ fn angle_shl_assign() {
                 Value = 0,
                 Size = 53
             };
-            set a = Std.OpenQASM.Angle.__AngleShl__(a, 1);
+            set a = Std.OpenQASM.Angle.AngleShl(a, 1);
         "#]],
     );
 }

source/compiler/qsc_openqasm_compiler/src/tests/declaration/def.rs

@@ -393,6 +393,7 @@ fn return_from_switch() {
             switch (a) {
                 case 0 { return 1; }
                 case 1 { return 0; }
+                default { return 0; }
             }
         }
     "#;
@@ -406,6 +407,8 @@ fn return_from_switch() {
                     return Std.OpenQASM.Convert.IntAsResult(1);
                 } elif a == 1 {
                     return Std.OpenQASM.Convert.IntAsResult(0);
+                } else {
+                    return Std.OpenQASM.Convert.IntAsResult(0);
                 };
             }
         "#]],

source/compiler/qsc_openqasm_compiler/src/tests/expression/binary/angle.rs

@@ -17,7 +17,7 @@ fn shl() -> miette::Result<(), Vec<Report>> {
 
     let qsharp = compile_qasm_stmt_to_qsharp(source)?;
     expect![[r#"
-        mutable x = Std.OpenQASM.Angle.__AngleShl__(a, b);
+        mutable x = Std.OpenQASM.Angle.AngleShl(a, b);
     "#]]
     .assert_eq(&qsharp);
     Ok(())