regorus/tests/rvm/vm/suites/loops/nested.yaml

name: "Nested Loops Test Suite"
description: "Test various combinations and levels of nesting for different looping constructs"

cases:
  - note: "simple_nested_comprehension"
    description: "Test simple nested array comprehension"
    example_rego: |
      [[x | x := [1, 2][_]] | _ := [1, 2][_]]
    literals:
      - 1
      - 2
    instruction_params:
      comprehension_begin_params:
        - mode: "Array"
          collection_reg: 1
          key_reg: 2
          value_reg: 3
          body_start: 6
          comprehension_end: 23
        - mode: "Array"
          collection_reg: 11
          key_reg: 12
          value_reg: 13
          body_start: 12
          comprehension_end: 20
      loop_params:
        - mode: "ForEach"
          collection: 6
          key_reg: 7
          value_reg: 8
          result_reg: 9
          body_start: 7
          loop_end: 22
        - mode: "ForEach"
          collection: 16
          key_reg: 17
          value_reg: 18
          result_reg: 19
          body_start: 15
          loop_end: 18
    instructions:
      - "ComprehensionBegin { params_index: 0 }"  # array comprehension in r1, body: 4-21 (P0)
      - "Load { dest: 4, literal_idx: 0 }"       # Load literal: 1
      - "Load { dest: 5, literal_idx: 1 }"       # Load literal: 2
      - "ArrayNew { dest: 6 }"                   # Create empty array r6
      - "ArrayPush { arr: 6, value: 4 }"         # Push r4 to r6
      - "ArrayPush { arr: 6, value: 5 }"         # Push r5 to r6 -> [1, 2]
      - "LoopStart { params_index: 0 }"          # foreach loop over r6, body: 8-20 (P0)
      # Outer loop body starts here (index 7)
      - "Move { dest: 10, src: 8 }"              # Copy value from r8 to r10
      - "ComprehensionBegin { params_index: 1 }" # array comprehension in r11, body: 10-18 (P1)
      - "Load { dest: 14, literal_idx: 0 }"      # Load literal: 1
      - "Load { dest: 15, literal_idx: 1 }"      # Load literal: 2
      - "ArrayNew { dest: 16 }"                  # Create empty array r16
      - "ArrayPush { arr: 16, value: 14 }"       # Push r14 to r16
      - "ArrayPush { arr: 16, value: 15 }"       # Push r15 to r16 -> [1, 2]
      - "LoopStart { params_index: 1 }"          # foreach loop over r16, body: 14-17 (P1)
      # Inner loop body starts here (index 16)
      - "Move { dest: 20, src: 18 }"             # Copy value from r18 to r20
      - "ComprehensionYield { value_reg: 20 }"   # Yield value to comprehension
      - "LoopNext { body_start: 16, loop_end: 19 }" # continue → 16 or exit → 19
      # Inner comprehension end (index 19)
      - "ComprehensionEnd"                        # End comprehension block
      - "ComprehensionYield { value_reg: 11 }"   # Yield value to comprehension
      - "LoopNext { body_start: 7, loop_end: 22 }" # continue → 7 or exit → 22
      # Outer comprehension end (index 22)
      - "ComprehensionEnd"                        # End comprehension block
      - "Move { dest: 0, src: 1 }"               # Copy value from r1 to r0
      - "Return { value: 0 }"                     # Return value from r0
    want_result: [[1, 2], [1, 2]]

  - note: "some_nested_comprehension"
    description: "Test some with nested array comprehension"
    example_rego: |
      [1, 2][_] == [x | x := [1, 2, 3][_]; x > 1][_]
    literals:
      - 1
      - 2
      - 3
    instruction_params:
      comprehension_begin_params:
        - mode: "Array"
          collection_reg: 12
          result_reg: 12
          key_reg: 10
          value_reg: 11
          body_start: 16
          comprehension_end: 20
      loop_params:
        - mode: "Any"
          collection: 0
          key_reg: 7
          value_reg: 8
          result_reg: 9
          body_start: 14
          loop_end: 27
        - mode: "ForEach"
          collection: 3
          key_reg: 10
          value_reg: 11
          result_reg: 21
          body_start: 16
          loop_end: 20
        - mode: "Any"
          collection: 12
          key_reg: 13
          value_reg: 14
          result_reg: 15
          body_start: 22
          loop_end: 25
    instructions:
      - "ArrayNew { dest: 0 }"              # Index 0: Build left array [1, 2]
      - "Load { dest: 1, literal_idx: 0 }"  # Index 1: Load literal 1
      - "ArrayPush { arr: 0, value: 1 }"    # Index 2
      - "Load { dest: 2, literal_idx: 1 }"  # Index 3: Load literal 2
      - "ArrayPush { arr: 0, value: 2 }"    # Index 4
      - "ArrayNew { dest: 3 }"              # Index 5: Build source array [1, 2, 3]
      - "Load { dest: 4, literal_idx: 0 }"  # Index 6
      - "ArrayPush { arr: 3, value: 4 }"    # Index 7
      - "Load { dest: 5, literal_idx: 1 }"  # Index 8
      - "ArrayPush { arr: 3, value: 5 }"    # Index 9
      - "Load { dest: 6, literal_idx: 2 }"  # Index 10
      - "ArrayPush { arr: 3, value: 6 }"    # Index 11
      - "Load { dest: 16, literal_idx: 0 }" # Index 12: Load 1 for comparison (stays stable)
      - "LoopStart { params_index: 0 }"     # Index 13: Start outer some loop over [1, 2]
      - "ComprehensionBegin { params_index: 0 }"  # Index 14: Build filtered comprehension
      - "LoopStart { params_index: 1 }"     # Index 15: Iterate source values for comprehension
      - "Gt { dest: 17, left: 11, right: 16 }"  # Index 16: Check x > 1
      - "AssertCondition { condition: 17 }"  # Index 17: Skip values <= 1
      - "ComprehensionYield { value_reg: 11 }"   # Index 18: Include qualifying value
      - "LoopNext { body_start: 16, loop_end: 20 }"  # Index 19: Continue comprehension loop
      - "ComprehensionEnd"                    # Index 20: Finish comprehension block
      - "LoopStart { params_index: 2 }"     # Index 21: Iterate comprehension results
      - "Eq { dest: 18, left: 8, right: 14 }"   # Index 22: Compare outer value with result value
      - "AssertCondition { condition: 18 }"  # Index 23: Success when values match
      - "LoopNext { body_start: 22, loop_end: 25 }"  # Index 24: Continue inner any loop
      - "AssertCondition { condition: 15 }"  # Index 25: Require some match from inner any loop
      - "LoopNext { body_start: 14, loop_end: 27 }"  # Index 26: Continue outer some loop
      - "Return { value: 9 }"                # Index 27
    want_result: true

  - note: "nested_with_condition"
    description: "Test nested loops with conditional logic"
    example_rego: |
      [x | x := [1, 2, 3][_]; x > 1]
    literals:
      - 1
      - 2
      - 3
    instruction_params:
      comprehension_begin_params:
        - mode: "Array"
          collection_reg: 6
          result_reg: 6
          key_reg: 4
          value_reg: 5
          body_start: 9
          comprehension_end: 14
      loop_params:
        - mode: "ForEach"
          collection: 0
          key_reg: 4
          value_reg: 5
          result_reg: 7
          body_start: 9
          loop_end: 14
    instructions:
      - "ArrayNew { dest: 0 }"              # Index 0: Create input array [1, 2, 3]
      - "Load { dest: 1, literal_idx: 0 }"  # Index 1: Load 1
      - "ArrayPush { arr: 0, value: 1 }"    # Index 2: Push 1 to array
      - "Load { dest: 2, literal_idx: 1 }"  # Index 3: Load 2
      - "ArrayPush { arr: 0, value: 2 }"    # Index 4: Push 2 to array
      - "Load { dest: 3, literal_idx: 2 }"  # Index 5: Load 3
      - "ArrayPush { arr: 0, value: 3 }"    # Index 6: Push 3 to array
      - "ComprehensionBegin { params_index: 0 }"  # Index 7: Start comprehension
      - "LoopStart { params_index: 0 }"     # Index 8: Start loop
      - "Load { dest: 7, literal_idx: 0 }"  # Index 9: Load 1 for comparison
      - "Gt { dest: 8, left: 5, right: 7 }" # Index 10: x > 1
      - "AssertCondition { condition: 8 }" # Index 11: Assert x > 1 (skip if false)
      - "ComprehensionYield { value_reg: 5 }"    # Index 12: Push x to result if condition true
      - "LoopNext { body_start: 9, loop_end: 13 }"  # Index 13: Continue loop
      - "Return { value: 6 }"               # Index 14: Return comprehension result
    want_result: [2, 3]