bdd0e96d78
A block's value is now its last statement ONLY when that statement is a trailing expression with no `;`. A trailing `;` discards the value, leaving the block void. This makes value-vs-statement explicit and lets the compiler reject "this block was supposed to produce a value". Compiler: - Parser records `Block.produces_value` (last stmt is a no-`;` trailing expression) + `Block.discarded_semi` (the `;` that discarded a value), via `expectSemicolonAfter`. A trailing expression before `}` may now omit its `;` (previously a parse error). Match-arm and else-arm bodies are built value-producing regardless of the arm `;` (arms are exempt — the `;` is an arm terminator). - Lowering: `lowerBlockValue` / the block-expr path / `inferExprType` respect `produces_value`. A value-position block that discards its value is a hard error (`lowerValueBody` for function bodies; the value-context `.block` path for if/else branches, `catch` bodies, value bindings, match arms). Pure-failable `-> !` bodies (value rides the error channel) and a value-if whose branches are void are handled without false errors. - `defer`/`onfail` cleanup bodies lower as statements (void), so a trailing `;` there is fine. Migration (behavior-preserving — output unchanged): - stdlib + ~210 examples: dropped the trailing `;` on value-position last expressions. `format` now ends with an explicit `#insert "return result;"` (it relied on `#insert`-as-block-value, which `;` discards). - Two `main :: () -> s32` examples that relied on the old silent default-return got an explicit trailing `0`. - Rejection snapshots 0412 / 1013 regenerated (their quoted source lines lost a `;`); the diagnostics themselves are unchanged. Docs/tests: specs.md "Block values" section; examples 0040 (rules) + 0041 (rejection); 3 parser unit tests. Filed issue 0066 (pre-existing match-arm negated-literal phi-width quirk, surfaced not caused here). Gates: zig build, zig build test, run_examples.sh -> 343 passed, cross_compile.sh -> 7 passed (also refreshed its stale example names).
95 lines
3.6 KiB
Plaintext
95 lines
3.6 KiB
Plaintext
#import "std.sx";
|
|
|
|
// =====================================================================
|
|
// trace.sx — error return-trace formatting (ERR step E3.3).
|
|
//
|
|
// Reads the thread-local return-trace buffer (ERR E3.1, populated by the
|
|
// push/clear wiring in E3.2) and renders it. A `raise` / propagating `try`
|
|
// pushes a frame; an absorbing site (`catch` / `or value` / destructure)
|
|
// clears the buffer. So at format time the buffer holds exactly the frames
|
|
// of failures that escaped to where you're formatting — typically inside a
|
|
// `catch` handler (the clear fires when the handler completes, so the body
|
|
// still sees the chain) or the (future) failable-`main` wrapper.
|
|
//
|
|
// Frame resolution (ERR E3.0 slice 3a): in compiled code a frame is a pointer
|
|
// to an interned `Frame` the compiler stamped in at the push site, so the
|
|
// location resolves in-process with no DWARF and no symbolizer. (The comptime
|
|
// path — a packed `(func_id, ir_offset)` resolved via the interpreter's IR
|
|
// tables — lands with slice 3b.)
|
|
// =====================================================================
|
|
|
|
libc :: #library "c";
|
|
|
|
// The compiled return-trace frame. Layout MUST match `getFrameStructType` in
|
|
// src/ir/emit_llvm.zig and `SxFrame` in library/vendors/sx_trace_runtime/sx_trace.c.
|
|
Frame :: struct {
|
|
file: string;
|
|
line: s32;
|
|
col: s32;
|
|
func: string;
|
|
line_text: string; // the source line, for the snippet + caret
|
|
}
|
|
|
|
// `n` spaces — used to position the `^` caret under a column.
|
|
spaces :: (n: s32) -> string {
|
|
s := "";
|
|
i : s32 = 0;
|
|
while i < n {
|
|
s = concat(s, " ");
|
|
i = i + 1;
|
|
}
|
|
s
|
|
}
|
|
|
|
// The error-trace buffer C API (library/vendors/sx_trace_runtime/sx_trace.c),
|
|
// linked in for the JIT and auto-injected for AOT when traces are used.
|
|
// `frame_at` returns the raw stored `u64`; `__trace_resolve_frame` turns it
|
|
// into a `Frame` — by reinterpreting the stamped `*Frame` in compiled code, or
|
|
// by resolving the packed `(func_id, span.start)` in the comptime interpreter.
|
|
sx_trace_len :: () -> u32 #foreign;
|
|
sx_trace_truncated :: () -> u32 #foreign;
|
|
sx_trace_frame_at :: (i: u32) -> u64 #foreign;
|
|
|
|
write :: (fd: s32, buf: [*]u8, count: usize) -> isize #foreign libc;
|
|
|
|
// Render the current trace buffer to a string (allocated from
|
|
// context.allocator). Empty buffer → "" so callers can cheaply skip output.
|
|
to_string :: () -> string {
|
|
n := sx_trace_len();
|
|
if n == 0 { return ""; }
|
|
|
|
result := "error return trace (most recent call last):\n";
|
|
if sx_trace_truncated() != 0 {
|
|
result = concat(result, " ... older frames omitted (buffer full)\n");
|
|
}
|
|
|
|
i : u32 = 0;
|
|
while i < n {
|
|
f := __trace_resolve_frame(sx_trace_frame_at(i));
|
|
result = concat(result, format(" {} at {}:{}:{}\n", f.func, f.file, f.line, f.col));
|
|
if f.line_text.len > 0 {
|
|
result = concat(result, format(" {}\n", f.line_text));
|
|
result = concat(result, concat(" ", concat(spaces(f.col - 1), "^\n")));
|
|
}
|
|
i = i + 1;
|
|
}
|
|
result
|
|
}
|
|
|
|
// Write the current trace to stderr (fd 2). No-op when the buffer is empty.
|
|
print_current :: () {
|
|
s := to_string();
|
|
if s.len > 0 {
|
|
write(2, s.ptr, xx s.len);
|
|
}
|
|
}
|
|
|
|
// Dump the comptime (`#run`) interpreter call-frame chain (ERR E4.1). At
|
|
// comptime the interpreter walks its active sx frames and appends them to the
|
|
// build output; in compiled code this folds to nothing (there is no
|
|
// interpreter stack — the only caller is a dead `is_comptime()` branch).
|
|
// Frame source locations await IR-offset resolution, so only names print today.
|
|
print_interpreter_frames :: () {
|
|
__interp_print_frames();
|
|
}
|