fix(flow): treat break-capable constant loops as divergence

Keep constant-condition loops from being marked as proven infinite when the body can break.

This preserves the stronger is_infinite signal for loops that really cannot exit, while letting MissingReturn accept a later explicit return when the loop can break at runtime. Add regression coverage for both constant-loop shapes before a trailing return.

Author: lewis6991

crates/emmylua_code_analysis/src/compilation/analyzer/lua/func_body.rs

@@ -178,8 +178,8 @@ where
                 return_points: body.return_points,
                 can_fall_through: body.can_break,
                 can_break: false,
-                is_infinite: body.can_fall_through || body.is_infinite,
-                may_diverge: body.may_diverge,
+                is_infinite: (body.can_fall_through && !body.can_break) || body.is_infinite,
+                may_diverge: (body.can_fall_through && body.can_break) || body.may_diverge,
             })
         }
         ConditionState::Dynamic => {
@@ -225,7 +225,11 @@ where
             flow.can_fall_through = true;
         }
         ConditionState::Falsy => {
-            flow.is_infinite = true;
+            if body.can_break {
+                flow.may_diverge = true;
+            } else {
+                flow.is_infinite = true;
+            }
         }
         ConditionState::Dynamic => {
             flow.can_fall_through = true;

crates/emmylua_code_analysis/src/diagnostic/test/check_return_count_test.rs

@@ -706,6 +706,42 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_missing_return_accepts_truthy_while_with_break_before_return() {
+        assert_missing_return_ok(
+            r#"
+            ---@return number
+            local function foo(done)
+                while true do
+                    if done then
+                        break
+                    end
+                end
+
+                return 1
+            end
+            "#,
+        );
+    }
+
+    #[test]
+    fn test_missing_return_accepts_infinite_repeat_with_break_before_return() {
+        assert_missing_return_ok(
+            r#"
+            ---@return number
+            local function foo(done)
+                repeat
+                    if done then
+                        break
+                    end
+                until false
+
+                return 1
+            end
+            "#,
+        );
+    }
+
     #[test]
     fn test_missing_return_rejects_dynamic_while_with_infinite_body_before_return() {
         assert_missing_return_error(