989e18b760
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.
419 lines
19 KiB
Zig
419 lines
19 KiB
Zig
// Parser tests — pin parse-level shapes the example corpus can't isolate
|
|
// (the corpus runs the full `sx run` pipeline, never the parser alone).
|
|
|
|
const std = @import("std");
|
|
const ast = @import("ast.zig");
|
|
const Node = ast.Node;
|
|
const Parser = @import("parser.zig").Parser;
|
|
|
|
// Lock: the comptime type-metaprogramming surface in `library/modules/std/meta.sx`
|
|
// must PARSE — the data types as struct/enum decls, and the four comptime builtins
|
|
// (`declare` / `define` / `type_info` / `field_type`) as bodyless `#builtin`
|
|
// consts. Mirrors the exact spellings in meta.sx.
|
|
test "parser: comptime type-metaprogramming surface parses" {
|
|
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
|
|
defer arena.deinit();
|
|
const alloc = arena.allocator();
|
|
|
|
const src =
|
|
\\EnumVariant :: struct {
|
|
\\ name: string;
|
|
\\ payload: Type;
|
|
\\}
|
|
\\EnumInfo :: struct {
|
|
\\ name: string;
|
|
\\ variants: []EnumVariant;
|
|
\\}
|
|
\\TypeInfo :: enum {
|
|
\\ `enum: EnumInfo;
|
|
\\}
|
|
\\declare :: () -> Type #builtin;
|
|
\\define :: (handle: Type, info: TypeInfo) -> Type #builtin;
|
|
\\type_info :: ($T: Type) -> TypeInfo #builtin;
|
|
\\field_type :: ($T: Type, idx: i64) -> Type #builtin;
|
|
\\
|
|
;
|
|
var parser = Parser.init(alloc, src);
|
|
const root = try parser.parse();
|
|
|
|
try std.testing.expect(root.data == .root);
|
|
const decls = root.data.root.decls;
|
|
try std.testing.expectEqual(@as(usize, 7), decls.len);
|
|
|
|
const Found = struct {
|
|
// A top-level `Name :: struct/enum {…}` parses to a `.struct_decl` /
|
|
// `.enum_decl` node DIRECTLY (not wrapped in a const_decl); only the
|
|
// `#builtin` forms are `.fn_decl`. Match on the shared `declName`.
|
|
fn byName(ds: []const *Node, name: []const u8) ?*const Node {
|
|
for (ds) |d| {
|
|
if (d.data.declName()) |n| {
|
|
if (std.mem.eql(u8, n, name)) return d;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
|
|
// Data types: struct / struct / enum, parsed as their decl nodes directly.
|
|
const ev = Found.byName(decls, "EnumVariant") orelse return error.MissingDecl;
|
|
try std.testing.expect(ev.data == .struct_decl);
|
|
const ei = Found.byName(decls, "EnumInfo") orelse return error.MissingDecl;
|
|
try std.testing.expect(ei.data == .struct_decl);
|
|
const ti = Found.byName(decls, "TypeInfo") orelse return error.MissingDecl;
|
|
try std.testing.expect(ti.data == .enum_decl);
|
|
|
|
// The single `` `enum `` variant of TypeInfo. The backtick raw escape
|
|
// stores the bare keyword as the variant name.
|
|
const ed = ti.data.enum_decl;
|
|
try std.testing.expectEqual(@as(usize, 1), ed.variant_names.len);
|
|
try std.testing.expectEqualStrings("enum", ed.variant_names[0]);
|
|
|
|
// Builtins: the `(params) -> Ret #builtin;` form parses as a `.fn_decl`
|
|
// (the `->` triggers the function-def path) whose body is a `#builtin`
|
|
// marker — same shape as the existing reflection builtins in core.sx.
|
|
for ([_][]const u8{ "declare", "define", "type_info", "field_type" }) |bn| {
|
|
const d = Found.byName(decls, bn) orelse return error.MissingDecl;
|
|
try std.testing.expect(d.data == .fn_decl);
|
|
try std.testing.expect(d.data.fn_decl.body.data == .builtin_expr);
|
|
try std.testing.expect(d.data.fn_decl.return_type != null);
|
|
}
|
|
}
|
|
|
|
// Lock: the `compiler`-library binding surface PARSES — `name :: #library "x";`
|
|
// (already supported) plus the postfix `abi(.compiler)` annotation, marking a
|
|
// compiler-domain / compiler-API function — no `extern`, no fake `#library`. The
|
|
// AST must carry `abi == .compiler`, `extern_export == .none`, `extern_lib ==
|
|
// null`, and a synthesized empty-block (bodiless) body.
|
|
test "parser: abi(.compiler) binding parses on a bodiless fn decl" {
|
|
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
|
|
defer arena.deinit();
|
|
const alloc = arena.allocator();
|
|
|
|
const src =
|
|
\\text_of :: (id: StringId) -> string abi(.compiler);
|
|
\\intern :: (s: string) -> StringId abi(.compiler);
|
|
\\
|
|
;
|
|
var parser = Parser.init(alloc, src);
|
|
const root = try parser.parse();
|
|
|
|
try std.testing.expect(root.data == .root);
|
|
const decls = root.data.root.decls;
|
|
try std.testing.expectEqual(@as(usize, 2), decls.len);
|
|
|
|
// The two `abi(.compiler)` fns: `.fn_decl` with the compiler-domain ABI set,
|
|
// NO extern linkage, NO bound library.
|
|
for ([_][]const u8{ "text_of", "intern" }) |bn| {
|
|
var found: ?*const Node = null;
|
|
for (decls) |d| {
|
|
if (d.data.declName()) |n| {
|
|
if (std.mem.eql(u8, n, bn)) found = d;
|
|
}
|
|
}
|
|
const d = found orelse return error.MissingDecl;
|
|
try std.testing.expect(d.data == .fn_decl);
|
|
const fd = d.data.fn_decl;
|
|
try std.testing.expectEqual(ast.ABI.compiler, fd.abi);
|
|
try std.testing.expectEqual(ast.ExternExportModifier.none, fd.extern_export);
|
|
try std.testing.expect(fd.extern_lib == null);
|
|
// Bodyless compiler-domain decl: synthesized empty block, no `#builtin`/`#compiler`.
|
|
try std.testing.expect(fd.body.data == .block);
|
|
}
|
|
}
|
|
|
|
// Lock: a bare `extern` (no abi annotation) leaves `abi == .default` — the
|
|
// unannotated case is unchanged by the new `abi(...)` slot.
|
|
test "parser: bare extern leaves abi == .default" {
|
|
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
|
|
defer arena.deinit();
|
|
const alloc = arena.allocator();
|
|
|
|
const src =
|
|
\\puts :: (s: *u8) -> i32 extern;
|
|
\\
|
|
;
|
|
var parser = Parser.init(alloc, src);
|
|
const root = try parser.parse();
|
|
const decls = root.data.root.decls;
|
|
try std.testing.expectEqual(@as(usize, 1), decls.len);
|
|
try std.testing.expect(decls[0].data == .fn_decl);
|
|
const fd = decls[0].data.fn_decl;
|
|
try std.testing.expectEqual(ast.ExternExportModifier.extern_, fd.extern_export);
|
|
try std.testing.expectEqual(ast.ABI.default, fd.abi);
|
|
}
|
|
|
|
// Lock: `abi(.c)` parses standalone (no extern/export) in the postfix slot — the
|
|
// migrated spelling of the old `callconv(.c)` on an ordinary function pointer /
|
|
// fn decl. And `abi(.naked)` parses (naked-asm ABI).
|
|
test "parser: abi(.c) and abi(.naked) parse standalone" {
|
|
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
|
|
defer arena.deinit();
|
|
const alloc = arena.allocator();
|
|
|
|
const src =
|
|
\\cb :: () -> i64 abi(.c) { 0; }
|
|
\\nk :: () -> i64 abi(.naked) { 0; }
|
|
\\
|
|
;
|
|
var parser = Parser.init(alloc, src);
|
|
const root = try parser.parse();
|
|
const decls = root.data.root.decls;
|
|
try std.testing.expectEqual(@as(usize, 2), decls.len);
|
|
try std.testing.expect(decls[0].data == .fn_decl);
|
|
try std.testing.expectEqual(ast.ABI.c, decls[0].data.fn_decl.abi);
|
|
try std.testing.expectEqual(ast.ExternExportModifier.none, decls[0].data.fn_decl.extern_export);
|
|
try std.testing.expect(decls[1].data == .fn_decl);
|
|
try std.testing.expectEqual(ast.ABI.naked, decls[1].data.fn_decl.abi);
|
|
}
|
|
|
|
// Lock: the postfix `abi(...)` slot PARSES on a STRUCT decl — `Name :: struct
|
|
// abi(.compiler) extern <lib> { … }`. The AST struct_decl carries the abi + the
|
|
// library handle in `extern_lib`, with the field list intact. Parse-only — the
|
|
// struct-weld semantics were stripped (compiler-API types are VM-native now); this
|
|
// just locks that the annotation slot still parses without perturbing fields.
|
|
test "parser: abi(...) extern <lib> annotation parses on a struct decl" {
|
|
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
|
|
defer arena.deinit();
|
|
const alloc = arena.allocator();
|
|
|
|
const src =
|
|
\\compiler :: #library "compiler";
|
|
\\Field :: struct abi(.compiler) extern compiler { name: StringId; ty: Type; }
|
|
\\
|
|
;
|
|
var parser = Parser.init(alloc, src);
|
|
const root = try parser.parse();
|
|
const decls = root.data.root.decls;
|
|
try std.testing.expectEqual(@as(usize, 2), decls.len);
|
|
|
|
try std.testing.expect(decls[1].data == .struct_decl);
|
|
const sd = decls[1].data.struct_decl;
|
|
try std.testing.expectEqual(ast.ABI.compiler, sd.abi);
|
|
try std.testing.expect(sd.extern_lib != null);
|
|
try std.testing.expectEqualStrings("compiler", sd.extern_lib.?);
|
|
// Field list survives the binding annotation.
|
|
try std.testing.expectEqual(@as(usize, 2), sd.field_names.len);
|
|
try std.testing.expectEqualStrings("name", sd.field_names[0]);
|
|
try std.testing.expectEqualStrings("ty", sd.field_names[1]);
|
|
}
|
|
|
|
// Lock: an ordinary struct (no binding) leaves `abi == .default` / `extern_lib ==
|
|
// null` — the new annotation slot doesn't perturb the common case.
|
|
test "parser: plain struct leaves abi == .default, extern_lib == null" {
|
|
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
|
|
defer arena.deinit();
|
|
const alloc = arena.allocator();
|
|
|
|
const src =
|
|
\\Point :: struct { x: i64; y: i64; }
|
|
\\
|
|
;
|
|
var parser = Parser.init(alloc, src);
|
|
const root = try parser.parse();
|
|
const decls = root.data.root.decls;
|
|
try std.testing.expectEqual(@as(usize, 1), decls.len);
|
|
try std.testing.expect(decls[0].data == .struct_decl);
|
|
const sd = decls[0].data.struct_decl;
|
|
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);
|
|
}
|