fix 3 bugs, scope/block depth confusion over-unwinds defers, stmt-expr goto bypasses defer cleanup, bare orelse comma split escapes braceless control flow

Author: dawnlarsson

.github/test.defer.c

@@ -4577,6 +4577,127 @@ static void test_defer_shadow_braceless_for_ifelse(void) {
 	}
 }
 
+// BUG78: scope_depth/block_depth type confusion in emit_defers_ex.
+// When non-SCOPE_BLOCK entries (SCOPE_CTRL_PAREN) are on the scope_stack,
+// the scope_stack index `d` diverges from block_depth. The old code compared
+// `d < stop_depth` where stop_depth is in block_depth units, causing
+// over-unwinding of defers for same-scope gotos inside stmt-exprs.
+static void test_scope_depth_overunwind(void) {
+	/* goto L is a forward jump WITHIN the same block inside a stmt-expr
+	 * that lives inside if(...). The SCOPE_CTRL_PAREN shifts scope indices.
+	 * The defer must fire exactly once (at scope exit), not at the goto. */
+	{
+		PrismResult r = prism_transpile_source(
+		    "int counter = 0;\n"
+		    "void f(void) {\n"
+		    "    if ( ({\n"
+		    "        {\n"
+		    "            defer { counter++; }\n"
+		    "            goto L;\n"
+		    "            L: ;\n"
+		    "        }\n"
+		    "        42;\n"
+		    "    }) ) {\n"
+		    "        (void)0;\n"
+		    "    }\n"
+		    "}\n",
+		    "bug78a.c", prism_defaults());
+		CHECK_EQ(r.status, PRISM_OK,
+		         "bug78-overunwind: transpiles OK");
+		if (r.status == PRISM_OK && r.output) {
+			/* The goto should NOT be wrapped with defer cleanup
+			 * because it stays within the same scope. Count
+			 * occurrences of "counter++" — should be exactly 1
+			 * (the scope-exit defer), not 2 (goto + scope-exit). */
+			const char *fn = strstr(r.output, "void f(");
+			CHECK(fn != NULL, "bug78-overunwind: function found");
+			if (fn) {
+				int count = 0;
+				const char *p = fn;
+				while ((p = strstr(p, "counter++")) != NULL) {
+					count++;
+					p += 9;
+				}
+				CHECK_EQ(count, 1,
+				         "bug78-overunwind: defer fires once (not over-unwound)");
+			}
+		}
+		prism_free(&r);
+	}
+	/* Backward same-scope goto with SCOPE_CTRL_PAREN on stack */
+	{
+		PrismResult r = prism_transpile_source(
+		    "int counter = 0;\n"
+		    "void f(void) {\n"
+		    "    if ( ({\n"
+		    "        {\n"
+		    "            defer { counter++; }\n"
+		    "            L: ;\n"
+		    "            static int j = 0;\n"
+		    "            if (!j) { j = 1; goto L; }\n"
+		    "        }\n"
+		    "        42;\n"
+		    "    }) ) {\n"
+		    "        (void)0;\n"
+		    "    }\n"
+		    "}\n",
+		    "bug78b.c", prism_defaults());
+		CHECK_EQ(r.status, PRISM_OK,
+		         "bug78-backward: transpiles OK");
+		if (r.status == PRISM_OK && r.output) {
+			const char *fn = strstr(r.output, "void f(");
+			CHECK(fn != NULL, "bug78-backward: function found");
+			if (fn) {
+				int count = 0;
+				const char *p = fn;
+				while ((p = strstr(p, "counter++")) != NULL) {
+					count++;
+					p += 9;
+				}
+				CHECK_EQ(count, 1,
+				         "bug78-backward: defer fires once (not over-unwound)");
+			}
+		}
+		prism_free(&r);
+	}
+}
+
+// BUG79: emit_range_no_prep flat-loops tokens without routing stmt-exprs
+// through walk_balanced. A goto inside a stmt-expr in an orelse LHS
+// bypasses defer cleanup.
+static void test_emit_range_no_prep_stmtexpr_defer(void) {
+	PrismResult r = prism_transpile_source(
+	    "int counter = 0;\n"
+	    "void f(void) {\n"
+	    "    int target = 0;\n"
+	    "    {\n"
+	    "        defer { counter++; }\n"
+	    "        *({ goto skip; &target; }) = 1 orelse 2;\n"
+	    "        (void)target;\n"
+	    "    }\n"
+	    "    return;\n"
+	    "skip:\n"
+	    "    return;\n"
+	    "}\n",
+	    "bug79.c", prism_defaults());
+	CHECK_EQ(r.status, PRISM_OK,
+	         "bug79-lhs-stmtexpr: transpiles OK");
+	if (r.status == PRISM_OK && r.output) {
+		/* The goto in the LHS stmt-expr must have defer cleanup.
+		 * Find "goto skip" and check that "counter++" appears before it */
+		const char *fn = strstr(r.output, "void f(");
+		CHECK(fn != NULL, "bug79-lhs-stmtexpr: function found");
+		if (fn) {
+			const char *gs = strstr(fn, "goto skip");
+			const char *cleanup = strstr(fn, "counter++");
+			CHECK(gs != NULL, "bug79-lhs-stmtexpr: goto found");
+			CHECK(cleanup != NULL && cleanup < gs,
+			      "bug79-lhs-stmtexpr: defer cleanup before goto");
+		}
+	}
+	prism_free(&r);
+}
+
 void run_defer_tests(void) {
 	printf("\n=== DEFER TESTS ===\n");
         test_defer_in_comma_expr_bug();
@@ -4847,4 +4968,10 @@ void run_defer_tests(void) {
 
 	// BUG: braceless for-body if/else and do/while prematurely clears for_name_hid
 	test_defer_shadow_braceless_for_ifelse();
+
+	// BUG78: scope_depth/block_depth type confusion over-unwinds defers
+	test_scope_depth_overunwind();
+
+	// BUG79: emit_range_no_prep missing stmt-expr dispatch
+	test_emit_range_no_prep_stmtexpr_defer();
 }

.github/test.orelse.c

@@ -6021,6 +6021,47 @@ static void test_nested_bracket_orelse_no_quadratic(void) {
 	prism_free(&r);
 }
 
+// BUG80: bare orelse with comma operator in braceless control flow.
+// The comma split produces two statements, but braceless if/for/while/else
+// only captures the first — the orelse assignment leaks out of scope.
+// Fix: emit_bare_orelse_impl wraps in { } when brace_wrap is set.
+static int _bug80_if_helper(int cond) {
+	int status = -1;
+	if (cond)
+		(void)0, status = 0 orelse 1;
+	return status;
+}
+
+static int _bug80_while_helper(void) {
+	int x = -1;
+	int once = 1;
+	while (once)
+		once = 0, x = 5 orelse 99;
+	return x;
+}
+
+static int _bug80_else_helper(int cond) {
+	int status = -1;
+	if (cond)
+		status = 42;
+	else
+		(void)0, status = 0 orelse 1;
+	return status;
+}
+
+void test_bare_orelse_comma_braceless(void) {
+	// if: cond=1 → body runs, status = 0 orelse 1 = 1 (0 is falsy)
+	CHECK_EQ(_bug80_if_helper(1), 1, "BUG80: braceless if cond=1 orelse fires");
+	// if: cond=0 → body skipped, status stays -1
+	CHECK_EQ(_bug80_if_helper(0), -1, "BUG80: braceless if cond=0 body skipped");
+	// while: once=1 → body runs, x = 5 (truthy)
+	CHECK_EQ(_bug80_while_helper(), 5, "BUG80: braceless while comma orelse");
+	// else: cond=1 → if-branch, status=42
+	CHECK_EQ(_bug80_else_helper(1), 42, "BUG80: braceless else cond=1 if-branch");
+	// else: cond=0 → else-branch, status = 0 orelse 1 = 1
+	CHECK_EQ(_bug80_else_helper(0), 1, "BUG80: braceless else cond=0 orelse fires");
+}
+
 void run_orelse_tests(void) {
 	test_orelse_return_null();
 	test_orelse_return_cast();
@@ -6363,4 +6404,7 @@ void run_orelse_tests(void) {
 
 	// BUG77: O(N^2) nested bracket orelse scanning
 	test_nested_bracket_orelse_no_quadratic();
+
+	// BUG80: bare orelse comma operator in braceless control flow
+	test_bare_orelse_comma_braceless();
 }

prism.c

@@ -1201,8 +1201,13 @@ static void emit_range(Token *start, Token *end) {
 // Like emit_range but skips TK_PREP_DIR tokens (for generated expressions
 // where preprocessor directives would be invalid, e.g. inside if-conditions).
 static void emit_range_no_prep(Token *start, Token *end) {
-	for (Token *t = start; t && t != end && t->kind != TK_EOF; t = tok_next(t))
-		if (t->kind != TK_PREP_DIR) emit_tok(t);
+	for (Token *t = start; t && t != end && t->kind != TK_EOF; t = tok_next(t)) {
+		if (t->kind == TK_PREP_DIR) continue;
+		if (match_ch(t, '(') && tok_next(t) && match_ch(tok_next(t), '{') && tok_match(t)) {
+			walk_balanced(t, true); t = tok_match(t); continue;
+		}
+		emit_tok(t);
+	}
 }
 
 // Like emit_range_no_prep but walks balanced () and [] groups through
@@ -1218,7 +1223,7 @@ static void emit_balanced_range(Token *start, Token *end) {
 }
 
 // Forward declarations — implementations below find_bare_orelse.
-static Token *emit_bare_orelse_impl(Token *t, Token *end, bool comma_term);
+static Token *emit_bare_orelse_impl(Token *t, Token *end, bool comma_term, bool brace_wrap);
 static Token *emit_deferred_orelse(Token *t, Token *end);
 static void emit_deferred_range(Token *start, Token *end);
 
@@ -1230,9 +1235,10 @@ static void emit_defers_ex(DeferEmitMode mode, int stop_depth) {
 		check_defer_shadow_at_exit(mode, stop_depth);
 
 	int current_defer = defer_count - 1;
+	int curr_bd = ctx->block_depth;
 	for (int d = ctx->scope_depth - 1; d >= 0; d--) {
 		if (scope_stack[d].kind != SCOPE_BLOCK) continue;
-		if (mode == DEFER_TO_DEPTH && d < stop_depth) break;
+		if (mode == DEFER_TO_DEPTH && curr_bd <= stop_depth) break;
 
 		ScopeNode *scope = &scope_stack[d];
 		for (int i = current_defer; i >= scope->defer_start_idx; i--) {
@@ -1241,6 +1247,7 @@ static void emit_defers_ex(DeferEmitMode mode, int stop_depth) {
 			out_char(';');
 		}
 		current_defer = scope->defer_start_idx - 1;
+		curr_bd--;
 
 		if (mode == DEFER_SCOPE) break;
 		if (mode == DEFER_BREAK && (scope->is_loop || scope->is_switch)) break;
@@ -1249,10 +1256,12 @@ static void emit_defers_ex(DeferEmitMode mode, int stop_depth) {
 }
 
 static bool has_defers_for(DeferEmitMode mode, int stop_depth) {
+	int curr_bd = ctx->block_depth;
 	for (int d = ctx->scope_depth - 1; d >= 0; d--) {
 		if (scope_stack[d].kind != SCOPE_BLOCK) continue;
-		if (mode == DEFER_TO_DEPTH && d < stop_depth) break;
+		if (mode == DEFER_TO_DEPTH && curr_bd <= stop_depth) break;
 		if (defer_count > scope_stack[d].defer_start_idx) return true;
+		curr_bd--;
 		if (mode == DEFER_BREAK && (scope_stack[d].is_loop || scope_stack[d].is_switch))
 			return false;
 		if (mode == DEFER_CONTINUE && scope_stack[d].is_loop) return false;
@@ -1486,11 +1495,13 @@ static void check_defer_shadow_at_exit(DeferEmitMode mode, int stop_depth) {
 	// Determine which defer indices will be pasted by this exit.
 	// Walk scopes the same way emit_defers_ex does, collecting the range.
 	int min_defer_idx = defer_count; // exclusive upper bound not needed; just track min
+	int curr_bd = ctx->block_depth;
 	for (int d = ctx->scope_depth - 1; d >= 0; d--) {
 		if (scope_stack[d].kind != SCOPE_BLOCK) continue;
-		if (mode == DEFER_TO_DEPTH && d < stop_depth) break;
+		if (mode == DEFER_TO_DEPTH && curr_bd <= stop_depth) break;
 		if (scope_stack[d].defer_start_idx < min_defer_idx)
 			min_defer_idx = scope_stack[d].defer_start_idx;
+		curr_bd--;
 		if (mode == DEFER_BREAK &&
 		    (scope_stack[d].is_loop || scope_stack[d].is_switch)) break;
 		if (mode == DEFER_CONTINUE && scope_stack[d].is_loop) break;
@@ -6028,7 +6039,7 @@ static bool orelse_has_chain(Token *start, bool comma_term) {
 // Returns the token after the statement, or NULL if no orelse was found.
 // `comma_term`: also treat ',' at depth 0 as statement terminator.
 // `end`: optional boundary (for deferred ranges).
-static Token *emit_bare_orelse_impl(Token *t, Token *end, bool comma_term) {
+static Token *emit_bare_orelse_impl(Token *t, Token *end, bool comma_term, bool brace_wrap) {
 	Token *orelse_tok = find_bare_orelse(t);
 	if (!orelse_tok || (end && tok_loc(orelse_tok) >= tok_loc(end)))
 		return NULL;
@@ -6038,33 +6049,26 @@ static Token *emit_bare_orelse_impl(Token *t, Token *end, bool comma_term) {
 
 	#define BARE_IS_END(s) (match_ch((s), ';') || (comma_term && match_ch((s), ',')))
 
-	// Skip past depth-0 commas before orelse — the comma operator separates
-	// independent sub-expressions and orelse only applies to the last one.
-	// Emit prefix tokens as a separate statement (comma → semicolon) because
-	// the orelse expansion may produce a block `{ ... }` which cannot appear
-	// after the comma operator.
+	// Find last depth-0 comma before orelse (search only — don't emit yet).
+	// Need to check is_bare_fallback before emitting, because if it's not
+	// bare we return NULL and the caller handles it differently.
+	Token *last_comma = NULL;
 	{
-		Token *last_comma = NULL;
 		int sd = 0;
 		for (Token *s = t; s != orelse_tok; s = tok_next(s)) {
 			if (s->flags & TF_OPEN) sd++;
 			else if (s->flags & TF_CLOSE) sd--;
-			else if (sd == 0 && match_ch(s, ',')) last_comma = s;
-		}
-		if (last_comma) {
-			for (Token *s = t; s != last_comma; s = tok_next(s))
-				emit_tok(s);
-			out_char(';');  // replace comma with semicolon
-			t = tok_next(last_comma);
+			else if (sd == 0 && comma_term && match_ch(s, ',')) last_comma = s;
 		}
 	}
+	Token *post_comma_t = last_comma ? tok_next(last_comma) : t;
 
 	// Find assignment target (= at depth 0 before orelse)
-	Token *bare_lhs_start = t;
+	Token *bare_lhs_start = post_comma_t;
 	Token *bare_assign_eq = NULL;
 	{
 		int sd = 0;
-		for (Token *s = t; s != orelse_tok; s = tok_next(s)) {
+		for (Token *s = post_comma_t; s != orelse_tok; s = tok_next(s)) {
 			if (s->flags & TF_OPEN) sd++;
 			else if (s->flags & TF_CLOSE) sd--;
 			else if (sd == 0 && is_assignment_operator_token(s)) {
@@ -6097,6 +6101,21 @@ static Token *emit_bare_orelse_impl(Token *t, Token *end, bool comma_term) {
 	if (!is_bare_fallback)
 		return NULL;  // caller handles non-bare fallback
 
+	// Now we know this is bare — safe to emit.
+	// Wrap in braces for braceless control-flow bodies (if/for/while/else
+	// without braces) so the expansion stays as a single compound statement.
+	if (brace_wrap) OUT_LIT(" {");
+
+	// Emit comma prefix as a separate statement (comma → semicolon).
+	// The orelse expansion may produce a block which cannot appear after
+	// the comma operator.
+	if (last_comma) {
+		for (Token *s = t; s != last_comma; s = tok_next(s))
+			emit_tok(s);
+		out_char(';');
+		t = post_comma_t;
+	}
+
 	// Reject if the statement contains preprocessor conditionals (#ifdef/#else/etc.).
 	// emit_range_no_prep / emit_balanced_range skip TK_PREP_DIR tokens,
 	// producing concatenated code from ALL branches — silent miscompilation.
@@ -6263,6 +6282,7 @@ static Token *emit_bare_orelse_impl(Token *t, Token *end, bool comma_term) {
 			OUT_LIT(" }");
 		}
 		if (match_ch(t, ';') || (comma_term && match_ch(t, ','))) t = tok_next(t);
+	if (brace_wrap) OUT_LIT(" }");
 	#undef BARE_IS_END
 	return t;
 }
@@ -6284,7 +6304,7 @@ static Token *emit_orelse_condition_wrap(Token *t, Token *orelse_tok) {
 // Wrapper for defer blocks: handles both bare and non-bare orelse.
 // Returns the token after the statement, or NULL if no orelse was found.
 static Token *emit_deferred_orelse(Token *t, Token *end) {
-	Token *result = emit_bare_orelse_impl(t, end, false);
+	Token *result = emit_bare_orelse_impl(t, end, false, false);
 	if (result) return result;
 
 	// Check for non-bare orelse (block/control-flow action)
@@ -8370,8 +8390,14 @@ static int transpile_tokens(Token *tok, FILE *fp) {
 						tok = label_end;
 					}
 
+					// Braceless control flow: bare orelse can emit multiple
+					// statements (comma split + assignment), so needs braces.
+					// Non-bare (control-flow/block action) already wraps in
+					// { if (!(...)) ... } which is a single compound statement.
+					bool brace_wrap = ctrl_state.pending && ctrl_state.parens_just_closed;
+
 					// Try bare-fallback path (handled by shared impl)
-					Token *next = emit_bare_orelse_impl(tok, NULL, true);
+					Token *next = emit_bare_orelse_impl(tok, NULL, true, brace_wrap);
 					if (next) {
 						tok = next;
 						end_statement_after_semicolon();