Prohibit return statements in apply block (#2839)

Fixes #2837

Author: swernli

katas/content/qec_shor/Common.qs

@@ -13,7 +13,7 @@ namespace Kata.Verification {
             for _ in 1..10 {
                 use qs = Qubit[n];
                 let theta = DrawRandomDouble(0.0, 1.0);
-                within {
+                let correct = within {
                     // Prepare logical state on first qubit
                     Ry(2.0 * theta * PI(), qs[0]);
                     // Encode the state in multiple qubits
@@ -30,9 +30,14 @@ namespace Kata.Verification {
                         Message("Incorrect.");
                         let actual = err_ind == -1 ? "No error happened" | $"Error happened on qubit {err_ind}";
                         Message($"{actual}, but solution returned {detected}");
-                        ResetAll(qs);
-                        return false;
+                        false
+                    } else {
+                        true
                     }
+                };
+                if not correct {
+                    ResetAll(qs);
+                    return false;
                 }
                 // Check that the state was not modified by the solution
                 if not CheckAllZero(qs) {

source/compiler/qsc_passes/src/conjugate_invert.rs

@@ -241,6 +241,8 @@ impl<'a> Visitor<'a> for ReturnCheck {
     fn visit_expr(&mut self, expr: &'a Expr) {
         if matches!(&expr.kind, ExprKind::Return(..)) {
             self.errors.push(Error::ReturnForbidden(expr.span));
+        } else {
+            visit::walk_expr(self, expr);
         }
     }
 }

source/compiler/qsc_passes/src/conjugate_invert/tests.rs

@@ -537,6 +537,39 @@ fn conjugate_return_in_apply_fail() {
     );
 }
 
+#[test]
+fn conjugate_return_nested_in_apply_fail() {
+    check(
+        indoc! {"
+            namespace Test {
+                operation B(i : Int) : Unit is Adj {}
+                operation A() : Unit {
+                    mutable a = 1;
+                    within {
+                        let x = a;
+                        B(2);
+                    }
+                    apply {
+                        if true {
+                            return ();
+                        }
+                    }
+                }
+            }
+        "},
+        &expect![[r#"
+            [
+                ReturnForbidden(
+                    Span {
+                        lo: 231,
+                        hi: 240,
+                    },
+                ),
+            ]
+        "#]],
+    );
+}
+
 #[test]
 fn conjugate_mutable_correct_use_succeeds() {
     check(