lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lang: catch/onfail error bindings take parens

Browse Source 
try foo() catch (e) { }   // legal
try foo() catch e { }     // parse error with a migration hint

Same capture style as the for-loop. All four catch shapes keep working
with the parenthesized binding — block, bare-expression body, and the
== match sugar — and the no-binding forms are unchanged. onfail follows
the same rule (onfail (e) { }); its expression-cleanup form is
disambiguated by the paren-group-before-brace lookahead, so
onfail (f()); stays an expression cleanup.

AST unchanged; the printer renders the parens; the #run escape help
text updated. Corpus migrated (57 catch + 3 onfail bindings, in-source
parser test strings, specs incl. grammar rules, readme untouched —
no catch examples there).

Regression: examples/1157-diagnostics-catch-binding-needs-parens.sx;
re-captured stderr for 1010/1013/1037/1123 (migrated source echoed in
carets + help text).
This commit is contained in:
agra
2026-06-10 23:05:02 +03:00
parent 12149eb548
commit 83ec2536af
42 changed files with 158 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
examples/1009-errors-catch.sx
View File

@@ -20,7 +20,7 @@ must :: (n: s32) -> !E {
// Diverging body — returns from `classify` on error.
classify :: (n: s32) -> s32 {
must(n) catch e {
must(n) catch (e) {
if e == error.Bad { return 1; }
if e == error.Empty { return 2; }
return 9;
@@ -28,9 +28,9 @@ classify :: (n: s32) -> s32 {
return 0; // must(n) succeeded
}
// Match-body form — sugar for `catch e { if e == { case ... } }`.
// Match-body form — sugar for `catch (e) { if e == { case ... } }`.
mclassify :: (n: s32) -> s32 {
must(n) catch e == {
must(n) catch (e) == {
case .Bad: return 11;
case .Empty: return 22;
else: return 99;
@@ -41,7 +41,7 @@ mclassify :: (n: s32) -> s32 {
// Selective handle + re-raise (failable enclosing fn; `raise e` is the
// variable form). Swallows Bad → success; re-raises everything else.
handle_some :: (n: s32) -> !E {
must(n) catch e {
must(n) catch (e) {
if e == error.Bad { return; } // swallow → success
raise e; // re-raise the rest
};
@@ -50,7 +50,7 @@ handle_some :: (n: s32) -> !E {
main :: () -> s32 {
r : s32 = 0;
must(-1) catch e { if e == error.Bad { r = r + 1; } }; // Bad → +1
must(-1) catch (e) { if e == error.Bad { r = r + 1; } }; // Bad → +1
must(5) catch { r = r + 100; }; // success → body skipped
r = r + classify(0); // Empty → 2
r = r + classify(8); // success → 0