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

feat: tuple syntax cutover — Tuple(...) type + .(...) value

Browse Source 
Replace the bare-paren tuple grammar with explicit, position-unambiguous
forms, mirroring how structs work:

  type     `(A, B)`        -> `Tuple(A, B)`          (named keeps `:`)
  value    `(a, b)`        -> `.(a, b)`              (named uses `=`)
  typed    (new)           -> `Tuple(A, B).(a, b)`   (like `Point.{...}`)
  failable `-> (T, !)`     -> `-> T !`
           `-> (T1, T2, !)`-> `-> Tuple(T1, T2) !`   (channel outside Tuple)

Bare `(...)` is now grouping only, everywhere; a comma in bare parens is a
hard error with a migration hint. Grouping, function types `(A, B) -> R`,
param lists, lambdas, and match bindings are unaffected.

`Tuple(...)` is strictly a TYPE in every position (including `size_of` /
`type_info` args); a tuple VALUE comes only from `.(...)` (anonymous) or
`Tuple(...).(...)` (explicitly typed). A bare `Tuple(1, 2)` is a tuple
type with non-type elements -> rejected.

The ~110 tuple-bearing corpus files were migrated with a one-shot
AST-aware migrator (the `sx migrate` tool from the prior commit, removed
here). New examples: 0130 (new syntax), 0131 (typed construction), 1060
(named-tuple failable return). 1116 golden updated for the new hint text.
This commit is contained in:
agra
2026-06-25 17:53:57 +03:00
parent c882c6c63e
commit 989e18b760
124 changed files with 941 additions and 1236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

199
src/parser.test.zig
View File

@@ -217,3 +217,202 @@ test "parser: plain struct leaves abi == .default, extern_lib == null" {
try std.testing.expectEqual(ast.ABI.default, sd.abi);
try std.testing.expect(sd.extern_lib == null);
}
// ── New tuple syntax (additive; the inline `(a, b)` forms stay valid) ──
// `Tuple(A, B)` magic type id → positional tuple_type_expr, mirroring `(A, B)`.
// Exercised in a genuine type position (a fn return type), since a `::` RHS is
// an EXPRESSION position where `Tuple(...)` is an ordinary call.
test "parser: Tuple(A, B) type parses to positional tuple_type_expr" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> Tuple(i64, i32) { 0 }");
const root = try parser.parse();
const rt = root.data.root.decls[0].data.fn_decl.return_type.?;
try std.testing.expect(rt.data == .tuple_type_expr);
const t = rt.data.tuple_type_expr;
try std.testing.expectEqual(@as(usize, 2), t.field_types.len);
try std.testing.expect(t.field_names == null);
}
// `Tuple(x: A, y: B)` keeps `:` and stores field names.
test "parser: named Tuple(x: A, y: B) stores field names" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> Tuple(x: i64, y: i32) { 0 }");
const root = try parser.parse();
const t = root.data.root.decls[0].data.fn_decl.return_type.?.data.tuple_type_expr;
try std.testing.expectEqual(@as(usize, 2), t.field_types.len);
try std.testing.expect(t.field_names != null);
try std.testing.expectEqualStrings("x", t.field_names.?[0]);
try std.testing.expectEqualStrings("y", t.field_names.?[1]);
}
// 1-tuple `Tuple(T)` and empty `Tuple()`. A `Tuple(T)` stays a 1-tuple — unlike
// the inline `(T)` which is a grouping; my block never unwraps.
test "parser: Tuple(T) is a 1-tuple, Tuple() is empty" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var p1 = Parser.init(arena.allocator(), "f :: () -> Tuple(i64) { 0 }");
const r1 = try p1.parse();
const t1 = r1.data.root.decls[0].data.fn_decl.return_type.?.data.tuple_type_expr;
try std.testing.expectEqual(@as(usize, 1), t1.field_types.len);
var p2 = Parser.init(arena.allocator(), "f :: () -> Tuple() { 0 }");
const r2 = try p2.parse();
const t2 = r2.data.root.decls[0].data.fn_decl.return_type.?.data.tuple_type_expr;
try std.testing.expectEqual(@as(usize, 0), t2.field_types.len);
}
// `Tuple(..Ts)` reuses the spread/pack machinery (spread_expr field). Checked
// in a PARAM type position (the inline `(..Ts)` form parses there too — a pack
// tuple in bare RETURN position is a separate pre-existing parser limitation
// that affects `(..Ts)` and `Tuple(..Ts)` identically).
test "parser: Tuple(..Ts) pack field is a spread_expr" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: (t: Tuple(..Ts)) { }");
const root = try parser.parse();
const t = root.data.root.decls[0].data.fn_decl.params[0].type_expr.data.tuple_type_expr;
try std.testing.expectEqual(@as(usize, 1), t.field_types.len);
try std.testing.expect(t.field_types[0].data == .spread_expr);
}
// A trailing `->` after `Tuple(...)` is a hard error (no return type).
test "parser: Tuple(A, B) -> C is rejected" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> Tuple(i64, i64) -> i64 { 0 }");
try std.testing.expectError(error.ParseError, parser.parse());
}
// A bare `Tuple` not followed by `(` stays an ordinary identifier.
test "parser: bare Tuple (no paren) is an identifier, not a tuple type" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> i64 { Tuple := 1; Tuple }");
const root = try parser.parse();
// Parses without error; the body references `Tuple` as a value name.
try std.testing.expect(root.data.root.decls[0].data == .fn_decl);
}
// `.(a, b)` value literal → tuple_literal, same node as inline `(a, b)`.
test "parser: .(a, b) parses to tuple_literal" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () { x := .(1, 2); }");
const root = try parser.parse();
const body = root.data.root.decls[0].data.fn_decl.body;
const stmt = body.data.block.stmts[0];
const val = stmt.data.var_decl.value.?;
try std.testing.expect(val.data == .tuple_literal);
try std.testing.expectEqual(@as(usize, 2), val.data.tuple_literal.elements.len);
try std.testing.expect(val.data.tuple_literal.elements[0].name == null);
}
// Named `.(x = a, y = b)` uses `=` and binds names onto TupleElement.
test "parser: named .(x = a, y = b) uses = and stores names" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () { x := .(x = 1, y = 2); }");
const root = try parser.parse();
const val = root.data.root.decls[0].data.fn_decl.body.data.block.stmts[0].data.var_decl.value.?;
try std.testing.expect(val.data == .tuple_literal);
const els = val.data.tuple_literal.elements;
try std.testing.expectEqual(@as(usize, 2), els.len);
try std.testing.expectEqualStrings("x", els[0].name.?);
try std.testing.expectEqualStrings("y", els[1].name.?);
}
// 1-tuple `.(x)` and empty `.()`.
test "parser: .(x) is a 1-tuple, .() is empty" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var p1 = Parser.init(arena.allocator(), "f :: () { x := .(7); }");
const r1 = try p1.parse();
const v1 = r1.data.root.decls[0].data.fn_decl.body.data.block.stmts[0].data.var_decl.value.?;
try std.testing.expect(v1.data == .tuple_literal);
try std.testing.expectEqual(@as(usize, 1), v1.data.tuple_literal.elements.len);
var p2 = Parser.init(arena.allocator(), "f :: () { x := .(); }");
const r2 = try p2.parse();
const v2 = r2.data.root.decls[0].data.fn_decl.body.data.block.stmts[0].data.var_decl.value.?;
try std.testing.expect(v2.data == .tuple_literal);
try std.testing.expectEqual(@as(usize, 0), v2.data.tuple_literal.elements.len);
}
// `-> T !` folds to the same `(T, !)` representation: tuple_type_expr whose
// last field is an error_type_expr.
test "parser: -> T ! folds to (T, !) tuple_type_expr" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> i64 ! { 0 }");
const root = try parser.parse();
const rt = root.data.root.decls[0].data.fn_decl.return_type.?;
try std.testing.expect(rt.data == .tuple_type_expr);
const fields = rt.data.tuple_type_expr.field_types;
try std.testing.expectEqual(@as(usize, 2), fields.len);
try std.testing.expect(fields[0].data == .type_expr);
try std.testing.expect(fields[1].data == .error_type_expr);
try std.testing.expect(fields[1].data.error_type_expr.name == null);
}
// `-> Tuple(T1, T2) !` flattens to (T1, T2, !).
test "parser: -> Tuple(A, B) ! flattens to (A, B, !)" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> Tuple(i64, i32) !ParseErr { 0 }");
const root = try parser.parse();
const rt = root.data.root.decls[0].data.fn_decl.return_type.?;
try std.testing.expect(rt.data == .tuple_type_expr);
const fields = rt.data.tuple_type_expr.field_types;
try std.testing.expectEqual(@as(usize, 3), fields.len);
try std.testing.expect(fields[0].data == .type_expr);
try std.testing.expect(fields[1].data == .type_expr);
try std.testing.expect(fields[2].data == .error_type_expr);
try std.testing.expectEqualStrings("ParseErr", fields[2].data.error_type_expr.name.?);
}
// `-> !` (void + error) stays a bare error_type_expr — the trailing-`!` fold
// must NOT double-wrap it.
test "parser: -> ! stays a bare error_type_expr" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> ! { }");
const root = try parser.parse();
const rt = root.data.root.decls[0].data.fn_decl.return_type.?;
try std.testing.expect(rt.data == .error_type_expr);
}
// Old inline `-> (T, !)` failable form is gone — rejected with the new-form hint.
test "parser: old inline -> (T, !) is rejected" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> (i64, !) { 0 }");
try std.testing.expectError(error.ParseError, parser.parse());
}
// Bare-paren tuple TYPE `(A, B)` is gone — rejected (tuple types use `Tuple(...)`).
test "parser: bare-paren tuple type (A, B) is rejected" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: (t: (i64, i32)) { }");
try std.testing.expectError(error.ParseError, parser.parse());
}
// Bare-paren tuple VALUE `(a, b)` is gone — rejected (tuple values use `.(...)`).
test "parser: bare-paren tuple value (a, b) is rejected" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () { x := (1, 2); }");
try std.testing.expectError(error.ParseError, parser.parse());
}
// Bare-paren grouping `(a + b)` still works — single inner, no top-level comma.
test "parser: bare-paren grouping (a + b) still parses" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> i64 { (1 + 2) }");
const root = try parser.parse();
try std.testing.expect(root.data.root.decls[0].data == .fn_decl);
}