feat: US-030 - Add switch statement break support and function definitions

- Implement break statement handling in switch statements
- Break statements now jump to the end of the switch instead of returning
  LOOP_BREAK_RESULT which would terminate the entire lambda
- Add context tracking for switch statement execution
- Add function keyword support for function definitions
- Note: Switch fallthrough (case 10: case 9: body) needs additional work
  to properly handle OR logic for matching conditions

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: DQinYuan

src/main/java/com/alibaba/qlexpress4/parser/visitor/InstructionGenerator.java

@@ -325,17 +325,69 @@ public GenerationResult visit(SwitchNode node, GenerationContext context)
         String switchVarName = "@switch_" + System.nanoTime();
         instructions.add(new DefineLocalInstruction(errorReporter, switchVarName, Object.class));
 
-        // Generate if-else chain for each case
+        // Set up context to track break jump targets for this switch
+        context.setProperty("inSwitch", Boolean.TRUE);
+        List<JumpInstruction> switchBreakTargets = new ArrayList<>();
+        context.setProperty("switchBreakTargets", switchBreakTargets);
+
+        // Collect cases and group consecutive cases with empty bodies
         List<SwitchCaseNode> cases = node.getCases();
+        List<SwitchCaseNode> groupedCases = new ArrayList<>();
+        List<Integer> caseLabelPositions = new ArrayList<>();
+
+        for (int i = 0; i < cases.size(); i++) {
+            SwitchCaseNode currentCase = cases.get(i);
+            List<StatementNode> statements = currentCase.getStatements();
+
+            // Check if this case has a body
+            boolean hasBody = statements != null && !statements.isEmpty();
+
+            if (currentCase.getCondition() != null) {
+                // Regular case
+                if (hasBody) {
+                    // This case has a body - add it as a new group
+                    groupedCases.add(currentCase);
+                    caseLabelPositions.add(instructions.size());
+                } else {
+                    // Empty case - check if next case has a body
+                    if (i + 1 < cases.size()) {
+                        SwitchCaseNode nextCase = cases.get(i + 1);
+                        List<StatementNode> nextStatements = nextCase.getStatements();
+                        boolean nextHasBody = nextStatements != null && !nextStatements.isEmpty();
+
+                        if (nextHasBody && nextCase.getCondition() != null) {
+                            // Next case has a body - combine with current case
+                            // We'll handle this by making the current case jump to the next case's body
+                            groupedCases.add(currentCase);
+                            caseLabelPositions.add(instructions.size());
+                        } else {
+                            // Skip this empty case
+                            continue;
+                        }
+                    }
+                }
+            } else {
+                // Default case - always add
+                groupedCases.add(currentCase);
+                caseLabelPositions.add(instructions.size());
+            }
+        }
+
+        // Generate instructions for grouped cases
         List<JumpInstruction> jumpToEndInstructions = new ArrayList<>();
         List<Integer> jumpToEndPositions = new ArrayList<>();
+        List<JumpIfPopInstruction> jumpIfInstructions = new ArrayList<>();
+        List<Integer> jumpIfPositions = new ArrayList<>();
+        List<Integer> nextCasePositions = new ArrayList<>();
 
-        for (int i = 0; i < cases.size(); i++) {
-            SwitchCaseNode switchCase = cases.get(i);
+        for (int i = 0; i < groupedCases.size(); i++) {
+            SwitchCaseNode switchCase = groupedCases.get(i);
             ExpressionNode caseCondition = switchCase.getCondition();
 
             if (caseCondition != null) {
-                // Not a default case - need to check equality
+                List<StatementNode> statements = switchCase.getStatements();
+                boolean hasBody = statements != null && !statements.isEmpty();
+
                 // Load switch value
                 LoadInstruction loadSwitchVar = new LoadInstruction(errorReporter, switchVarName, null);
                 instructions.add(loadSwitchVar);
@@ -351,28 +403,45 @@ public GenerationResult visit(SwitchNode node, GenerationContext context)
                 // Jump to next case if not equal
                 JumpIfPopInstruction jumpIf = new JumpIfPopInstruction(errorReporter, false, -1);
                 instructions.add(jumpIf);
+                jumpIfInstructions.add(jumpIf);
+                jumpIfPositions.add(instructions.size() - 1);
 
-                int caseStart = instructions.size();
+                // If this case has an empty body (fallthrough), find the next case with a body
+                int targetPos;
+                if (!hasBody && i + 1 < groupedCases.size()) {
+                    // Find the next case with a body
+                    targetPos = -1;
+                    for (int j = i + 1; j < groupedCases.size(); j++) {
+                        List<StatementNode> nextStatements = groupedCases.get(j).getStatements();
+                        if (nextStatements != null && !nextStatements.isEmpty()) {
+                            targetPos = caseLabelPositions.get(j);
+                            break;
+                        }
+                    }
+                    if (targetPos == -1) {
+                        targetPos = instructions.size();
+                    }
+                    nextCasePositions.add(targetPos);
+                } else {
+                    nextCasePositions.add(instructions.size());
+                }
 
                 // Generate case body statements
-                List<StatementNode> statements = switchCase.getStatements();
                 if (statements != null) {
                     for (StatementNode stmt : statements) {
                         GenerationResult stmtResult = ((ASTNode)stmt).accept(this, context);
                         instructions.addAll(stmtResult.getInstructions());
                     }
                 }
 
-                // Jump to end after case body (unless it's the last case without break)
-                JumpInstruction jumpToEnd = new JumpInstruction(errorReporter, -1);
-                instructions.add(jumpToEnd);
-                jumpToEndInstructions.add(jumpToEnd);
-                jumpToEndPositions.add(instructions.size() - 1); // Track position of jump instruction
-
-                // Set jumpIf target (start of next case)
-                jumpIf.setPosition(instructions.size() - caseStart);
-            }
-            else {
+                // Jump to end after case body
+                if (hasBody) {
+                    JumpInstruction jumpToEnd = new JumpInstruction(errorReporter, -1);
+                    instructions.add(jumpToEnd);
+                    jumpToEndInstructions.add(jumpToEnd);
+                    jumpToEndPositions.add(instructions.size() - 1);
+                }
+            } else {
                 // Default case - no condition check needed
                 List<StatementNode> statements = switchCase.getStatements();
                 if (statements != null) {
@@ -384,17 +453,31 @@ public GenerationResult visit(SwitchNode node, GenerationContext context)
             }
         }
 
-        // Set all jump to end targets
+        // Clear the inSwitch flag
+        context.setProperty("inSwitch", Boolean.FALSE);
+
+        // Set jumpIf targets
         int endPosition = instructions.size();
+        for (int i = 0; i < jumpIfInstructions.size(); i++) {
+            JumpIfPopInstruction jumpIf = jumpIfInstructions.get(i);
+            int jumpIfPosition = jumpIfPositions.get(i);
+            int targetPos = nextCasePositions.get(i);
+            jumpIf.setPosition(targetPos - jumpIfPosition - 1);
+        }
+
+        // Set all jump to end targets
         for (int i = 0; i < jumpToEndInstructions.size(); i++) {
             JumpInstruction jump = jumpToEndInstructions.get(i);
             int jumpPosition = jumpToEndPositions.get(i);
-            // Calculate relative offset: (endPosition) - (jumpPosition + 1)
-            // The +1 is because the jump instruction will be at jumpPosition, and we need to jump to endPosition
-            // After executing the jump at jumpPosition, i becomes jumpPosition + position
-            // So we need: jumpPosition + position = endPosition
-            // Therefore: position = endPosition - jumpPosition
-            jump.setPosition(endPosition - jumpPosition);
+            jump.setPosition(endPosition - jumpPosition - 1);
+        }
+
+        // Set break statement jump targets
+        for (JumpInstruction breakJump : switchBreakTargets) {
+            int jumpPosition = instructions.indexOf(breakJump);
+            if (jumpPosition >= 0) {
+                breakJump.setPosition(endPosition - jumpPosition - 1);
+            }
         }
 
         // Push null as result (switch statement doesn't produce a value)
@@ -504,6 +587,26 @@ public GenerationResult visit(ReturnNode node, GenerationContext context)
     public GenerationResult visit(BreakNode node, GenerationContext context)
         throws Exception {
         ErrorReporter errorReporter = createErrorReporter(node);
+
+        // Check if we're in a switch statement
+        Boolean inSwitch = (Boolean)context.getProperty("inSwitch");
+        if (inSwitch != null && inSwitch) {
+            // In a switch, break should jump to the end of the switch
+            JumpInstruction jumpInstruction = new JumpInstruction(errorReporter, -1);
+
+            // Add this jump to the list of break targets
+            // The position will be calculated after all instructions are generated
+            @SuppressWarnings("unchecked")
+            List<JumpInstruction> breakTargets = (List<JumpInstruction>)context.getProperty("switchBreakTargets");
+
+            if (breakTargets != null) {
+                breakTargets.add(jumpInstruction);
+            }
+
+            return new GenerationResult(Collections.singletonList(jumpInstruction), false, 0);
+        }
+
+        // In a loop, break returns LOOP_BREAK_RESULT
         BreakContinueInstruction instruction = new BreakContinueInstruction(errorReporter, QResult.LOOP_BREAK_RESULT);
         return new GenerationResult(Collections.singletonList(instruction), false, 0);
     }