Fix #337: break/continue outside a loop are compile errors

They compiled to silent no-ops (an explicit OP_NULL), so a mis-indented
break left its loop spinning with no diagnostic — including inside a
function body with no loop of its own. Both now report a compile error
via the existing post-compile g_parse_errors gate.

The gate is also enforced at every dynamic entry point: eval,
load_file, and import checked g_parse_errors only after PARSE, so
compile-stage diagnostics executed a placeholder chunk anyway. All
three now fail with a catchable error (the REPL and main already
gated).

Module-level return (ends the program, value discarded, exit 0) is now
documented in SPEC.md's Program model; the Loops section documents the
new compile error.

test_break_scope.eigs and test_control_flow_interactions.eigs pinned
the old tolerated-no-op shape; both rewritten to pin the actual
property (a callee's break never escapes to the caller's loop) using
functions that break their OWN loops.

Regression: suite [112] test_stray_break.eigs (eval'd stray
break/continue raise catchably; in-loop eval still works) + two
examples/errors/ demos gated by [90]. Release + ASan(detect_leaks=1)
2353/2353, leak tally 0.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: InauguralPhysicist

CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to EigenScript are documented here.
 ## [Unreleased]
 
 ### Fixed
+- **`break`/`continue` outside a loop are now compile errors (#337).** They
+  compiled to silent no-ops (an explicit `OP_NULL`), so a mis-indented `break`
+  left its loop spinning with no diagnostic — including inside a function body
+  with no loop of its own (a break there never crosses frames to the caller's
+  loop). Both now report `Compile error line N: 'break' outside a loop` and
+  abort via the existing post-compile gate. The same gate is now enforced at
+  every dynamic entry point: `eval`, `load_file`, and `import` previously
+  checked `g_parse_errors` only after *parse*, so compile-stage diagnostics
+  executed a placeholder chunk anyway — all three now fail with a catchable
+  error. Module-level `return` (ends the program, value discarded, exit 0) is
+  now documented in SPEC.md's Program model. Regression: section [112]
+  (`test_stray_break.eigs`) + two new `examples/errors/` demos gated by [90].
 - **f-string interpolation: whitespace and nested-string braces (#334).** Two
   lexer defects. (1) `f"{ x }"` (leading space) failed with "unexpected indent
   in expression": the interpolation body is re-lexed as a fresh source string

docs/SPEC.md

@@ -47,7 +47,9 @@ An EigenScript program is a sequence of statements executed top to
 bottom. There is no required entry point — the file *is* the program.
 Statements are expressions, assignments, definitions, or control
 structures. Blocks are delimited by indentation (like Python), and a
-statement ends at the end of its line.
+statement ends at the end of its line. A `return` at module level ends
+the program immediately (exit status 0); the returned value is
+discarded.
 
 Function application uses the keyword `of`: `f of x` calls `f` with the
 argument `x`. `print` is an ordinary builtin function.
@@ -339,7 +341,9 @@ medium
 `loop while cond:` repeats while the condition is truthy. `for v in
 seq:` iterates a list, buffer, or `range of n` (0 to n-1). `break` and
 `continue` behave conventionally and do not escape function-call
-boundaries.
+boundaries. A `break` or `continue` with no enclosing loop — including
+inside a function body that has no loop of its own — is a **compile
+error** (`'break' outside a loop`), not a silent no-op.
 
 ```eigenscript
 i is 0

examples/errors/break_outside_loop.eigs

@@ -0,0 +1,9 @@
+# ERROR DEMO — break/continue need an enclosing loop.
+# A break (or continue) with no loop around it — including inside a
+# function body that has no loop of its own — is a compile error, not
+# a silent no-op: a mis-indented break would otherwise leave its loop
+# spinning with no diagnostic (#337).
+# expect-error: Compile error line 8: 'break' outside a loop
+x is 1
+break
+print of "never runs"

examples/errors/continue_outside_loop.eigs

@@ -0,0 +1,9 @@
+# ERROR DEMO — continue outside a loop, in a function body. Function
+# bodies compile with their own loop context: a continue in a loop-less
+# function does NOT belong to a loop the caller might be running (#337).
+# expect-error: Compile error line 7: 'continue' outside a loop
+define helper as:
+    if n > 0:
+        continue
+    return 1
+print of (str of (helper of 5))

src/builtins.c

@@ -2446,10 +2446,20 @@ Value* builtin_load_file(Value *arg) {
         runtime_error(0, "load_file: parse error in '%s'", arg->data.str);
         return make_null();
     }
-    g_parse_errors = saved_errors;
-
+    /* Compile-stage diagnostics must fail the load too (#337) — same
+     * rationale as eval above. */
     Env *target = g_load_env ? g_load_env : g_global_env;
     EigsChunk *lf_chunk = compile_ast(ast, target);
+    if (g_parse_errors > 0) {
+        g_parse_errors = saved_errors;
+        chunk_free(lf_chunk);
+        free_ast(ast);
+        free_tokenlist(&tl);
+        free(source);
+        runtime_error(0, "load_file: compile error in '%s'", arg->data.str);
+        return make_null();
+    }
+    g_parse_errors = saved_errors;
     Value *result = vm_execute(lf_chunk, target);
     chunk_free(lf_chunk);   /* creator ref; loaded fns hold their own */
     free_ast(ast);
@@ -3297,10 +3307,20 @@ Value* builtin_eval(Value *arg) {
         runtime_error(0, "eval: parse error in code string");
         return make_null();
     }
-    g_parse_errors = saved_errors;
-
+    /* Keep the zeroed counter through COMPILE too — compile-stage
+     * diagnostics ('break' outside a loop #337, un-encodable jumps) must
+     * fail the eval instead of executing a placeholder chunk. */
     Env *target = g_builtin_call_env ? g_builtin_call_env : g_global_env;
     EigsChunk *ev_chunk = compile_ast(ast, target);
+    if (g_parse_errors > 0) {
+        g_parse_errors = saved_errors;
+        chunk_free(ev_chunk);
+        free_tokenlist(&tl);
+        free_ast(ast);
+        runtime_error(0, "eval: compile error in code string");
+        return make_null();
+    }
+    g_parse_errors = saved_errors;
     Value *result = vm_execute(ev_chunk, target);
     /* Chunks are refcounted: drop the creator ref; fn values keep their
      * nested chunks alive. */

src/compiler.c

@@ -1747,7 +1747,15 @@ static void compile_node_inner(Compiler *c, ASTNode *node) {
             /* Phantom +1 for stack accounting (dead code follows jump) */
             adjust_stack(c, 1);
         } else {
-            /* Break outside loop: emit null (no-op, maintains stack balance) */
+            /* Break outside any loop: a compile error (#337). This used to
+             * be a silent no-op, turning a mis-indented break into a loop
+             * that never exits. Emit OP_NULL so compilation continues with
+             * balanced stack accounting; the post-compile g_parse_errors
+             * gate aborts before execution. */
+            fprintf(stderr, "Compile error line %d: 'break' outside a loop\n",
+                    node->line);
+            eigs_record_first_error(node->line, "'break' outside a loop");
+            g_parse_errors++;
             emit(c, OP_NULL, node->line);
         }
         break;
@@ -1760,7 +1768,12 @@ static void compile_node_inner(Compiler *c, ASTNode *node) {
             /* Phantom +1 for stack accounting (dead code follows jump) */
             adjust_stack(c, 1);
         } else {
-            /* Continue outside loop: emit null */
+            /* Continue outside any loop: a compile error (#337), same
+             * rationale as break above. */
+            fprintf(stderr, "Compile error line %d: 'continue' outside a loop\n",
+                    node->line);
+            eigs_record_first_error(node->line, "'continue' outside a loop");
+            g_parse_errors++;
             emit(c, OP_NULL, node->line);
         }
         break;

src/vm.c

@@ -4418,7 +4418,8 @@ static Value *vm_run(EigsChunk *chunk, Env *env) {
             vm_push(make_null());
             DISPATCH();
         }
-        g_parse_errors = saved_errors;
+        /* Compile-stage diagnostics gate below (#337) — the counter stays
+         * zeroed through compile_ast, mirroring eval/load_file. */
 
         Env *saved_load = g_load_env;
         g_load_env = mod_env;
@@ -4443,6 +4444,20 @@ static Value *vm_run(EigsChunk *chunk, Env *env) {
         }
 
         EigsChunk *mod_chunk = compile_ast(ast, mod_env);
+        if (g_parse_errors > 0) {
+            g_parse_errors = saved_errors;
+            chunk_free(mod_chunk);
+            g_load_env = saved_load;
+            memcpy(g_import_resolve_dir, saved_resolve_dir, sizeof(saved_resolve_dir));
+            free_ast(ast);
+            free_tokenlist(&tl);
+            free(source);
+            env_decref(mod_env);
+            runtime_error(current_line, "import: compile errors in '%s'", name);
+            vm_push(make_null());
+            DISPATCH();
+        }
+        g_parse_errors = saved_errors;
         Value *mod_result = vm_execute(mod_chunk, mod_env);
         if (mod_result) val_decref(mod_result);
         chunk_free(mod_chunk);   /* creator ref; module fns hold their own */

tests/run_all_tests.sh

@@ -933,6 +933,13 @@ check_eigs_suite "65th break in for/while; break in 33rd nested loop" test_loop_
 echo "[111] Statement Cap: 4200-stmt program + block (#327)"
 check_eigs_suite "no silent truncation past 4096 statements" test_stmt_cap.eigs "All tests passed" 1
 
+# [112] stray break/continue (#337). Outside any loop they are compile
+# errors (were silent no-ops); compile-stage diagnostics fail eval /
+# load_file / import with a catchable error instead of running a
+# placeholder chunk. Direct-source rc=1 covered by examples/errors/ [90].
+echo "[112] Stray break/continue Are Compile Errors (#337)"
+check_eigs_suite "eval'd stray break/continue raise; in-loop still works" test_stray_break.eigs "All tests passed" 1
+
 # [23] Named parameters
 echo "[23/27] Named Parameters (9 checks)"
 NP_OUTPUT=$(./eigenscript ../tests/test_named_params.eigs 2>&1); NP_OUTPUT_RC=$?

tests/test_break_scope.eigs

@@ -1,10 +1,19 @@
-# break/continue must not escape function call boundaries
+# break/continue must not escape function call boundaries.
+# (#337 update: a break/continue in a LOOP-LESS function is now a compile
+# error — pinned by examples/errors/break_outside_loop.eigs and
+# continue_outside_loop.eigs. The no-escape property is pinned here with
+# functions that break/continue their OWN loops while the CALLER is
+# looping: the callee's break must never touch the caller's loop.)
 
 define breaker as:
-    break
+    for j in [1, 2]:
+        break
+    return 0
 
 define continuer as:
-    continue
+    for j in [1, 2]:
+        continue
+    return 0
 
 # break inside called function must not break caller's loop
 count is 0
@@ -20,13 +29,15 @@ for i in [1, 2, 3]:
     total is total + i
 assert of [total == 6, "continue inside function must not escape to caller loop"]
 
-# break inside nested call must not escape
+# break inside nested call must not escape through two frames
 define inner_break as:
-    break
+    loop while 1:
+        break
+    return 41
 
 define outer_fn as:
-    inner_break of null
-    return 42
+    r is inner_break of null
+    return r + 1
 
 result is 0
 for i in [1, 2, 3]:

tests/test_control_flow_interactions.eigs

@@ -4,8 +4,11 @@
 # === BREAK/CONTINUE ACROSS FUNCTION BOUNDARIES ===
 
 # --- break in function must not break caller's for loop ---
+# (#337: a loop-less break is now a compile error, so the callee breaks
+# its OWN loop; the property under test — never the CALLER's — is unchanged.)
 define do_break as:
-    break
+    for jb in [1, 2]:
+        break
 
 count is 0
 for i in [1, 2, 3, 4, 5]:
@@ -16,7 +19,8 @@ assert of [count == 5, "CF1 break in function does not escape for"]
 # --- continue in function must not skip caller's loop body ---
 total is 0
 define do_continue as:
-    continue
+    for jc in [1, 2]:
+        continue
 
 for i in [1, 2, 3]:
     do_continue of null
@@ -34,7 +38,8 @@ assert of [wcount == 5, "CF3 break in function does not escape while"]
 
 # --- nested: break in inner function, called from outer function, in loop ---
 define inner_break as:
-    break
+    loop while 1:
+        break
 
 define outer_call as:
     inner_break of null
@@ -138,7 +143,8 @@ assert of [classify of 99 == "other", "CF19 return from wildcard"]
 fns is []
 for i in range of 3:
     define f(x) as:
-        break
+        for kf in [1, 2]:
+            break
         return x
     append of [fns, f]