Test nested control-flow macro exit targets

Signed-off-by: Perfloop Agent <agent@perfloop.ai>
Signed-off-by: Tomás Senart <ts@perfloop.ai>

Author: perfloop-agent

libcc2rs-macros/tests/control_flow.rs

@@ -476,3 +476,144 @@ fn goto_block_nested_loop_break_targets_inner() {
     });
     assert_eq!(sum, 103);
 }
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Exit {
+    None,
+    Break,
+    Continue,
+    LabelledBreak,
+    LabelledContinue,
+}
+
+// Build the entire invocation before expanding a procedural macro, so the
+// outer macro sees the nested control-flow macros rather than a test helper.
+macro_rules! wrap {
+    ($trace:ident, $i:ident; [$($body:tt)*];) => { $($body)* };
+    ($trace:ident, $i:ident; [$($body:tt)*]; G $($rest:tt)*) => {
+        wrap!($trace, $i; [
+            $trace.push(($i, "goto enter"));
+            goto_block!({ 'entry: { $($body)* } });
+            $trace.push(($i, "goto tail"));
+        ]; $($rest)*);
+    };
+    ($trace:ident, $i:ident; [$($body:tt)*]; S $($rest:tt)*) => {
+        wrap!($trace, $i; [
+            $trace.push(($i, "switch enter"));
+            switch!(match 0 { _ => { $($body)* } });
+            $trace.push(($i, "switch tail"));
+        ]; $($rest)*);
+    };
+}
+
+fn reference(words: &[&str], action: Exit, trigger: usize) -> Vec<(usize, &'static str)> {
+    fn body(words: &[&str], exit: Exit, i: usize, trace: &mut Vec<(usize, &'static str)>) -> Exit {
+        let Some((word, rest)) = words.split_last() else {
+            trace.push((i, "action"));
+            if exit == Exit::None {
+                trace.push((i, "after action"));
+            }
+            return exit;
+        };
+        let is_switch = *word == "S";
+        trace.push((
+            i,
+            if is_switch {
+                "switch enter"
+            } else {
+                "goto enter"
+            },
+        ));
+        let mut exit = body(rest, exit, i, trace);
+        if is_switch && exit == Exit::Break {
+            exit = Exit::None;
+        }
+        if exit == Exit::None {
+            trace.push((
+                i,
+                if is_switch {
+                    "switch tail"
+                } else {
+                    "goto tail"
+                },
+            ));
+        }
+        exit
+    }
+    let mut trace = Vec::new();
+    for i in 0..3 {
+        trace.push((i, "enter"));
+        let exit = if i == trigger { action } else { Exit::None };
+        match body(words, exit, i, &mut trace) {
+            Exit::Break | Exit::LabelledBreak => break,
+            Exit::Continue | Exit::LabelledContinue => continue,
+            Exit::None => trace.push((i, "tail")),
+        }
+    }
+    trace
+}
+
+#[test]
+fn nested_loop_exit_targets() {
+    let mut mismatches = Vec::new();
+    macro_rules! check {
+        ($($words:tt)*) => {
+            for action in [Exit::None, Exit::Break, Exit::Continue,
+                           Exit::LabelledBreak, Exit::LabelledContinue] {
+                for trigger in 0..4 {
+                    let mut trace = Vec::new();
+                    let mut visits = 0;
+                    'user: for i in 0..3 {
+                        trace.push((i, "enter"));
+                        wrap!(trace, i; [
+                            visits += 1;
+                            if visits > 8 {
+                                trace.push((i, "visit limit"));
+                                break 'user;
+                            }
+                            trace.push((i, "action"));
+                            if i == trigger {
+                                match action {
+                                    Exit::None => {},
+                                    Exit::Break => break,
+                                    Exit::Continue => continue,
+                                    Exit::LabelledBreak => break 'user,
+                                    Exit::LabelledContinue => continue 'user,
+                                }
+                            }
+                            trace.push((i, "after action"));
+                        ]; $($words)*);
+                        trace.push((i, "tail"));
+                    }
+                    let words: Vec<_> = stringify!($($words)*).split_whitespace().collect();
+                    let expected = reference(&words, action, trigger);
+                    if trace != expected {
+                        mismatches.push((stringify!($($words)*), action, trigger, trace, expected));
+                    }
+                }
+            }
+        };
+    }
+    // Reduced nested-goto replay first, then every other word of depth 0..3.
+    check!(G G);
+    check!();
+    check!(G);
+    check!(S);
+    check!(G S);
+    check!(S G);
+    check!(S S);
+    check!(G G G);
+    check!(G G S);
+    check!(G S G);
+    check!(G S S);
+    check!(S G G);
+    check!(S G S);
+    check!(S S G);
+    check!(S S S);
+    assert_eq!(
+        mismatches.len(),
+        0,
+        "loop-exit target traces differ; first mismatch: {:?}",
+        mismatches.first()
+    );
+}