parse func decls

source/parser/parser.test.hon

@@ -3,6 +3,7 @@ import "@std/testing"
 
 import "@source/strpool"
 import "@source/lexer"
+import "@source/ast"
 
 ast_renderer :: import "@source/ast/renderer"
 
@@ -122,3 +123,80 @@ handles_statement_declaration test {
         try testing.expect_equal(expected.str_id, actual.str_id)
     }
 }
+
+handles_function_declarations test {
+    strpool.STRINGS = strpool.init(mem.c_allocator)
+    defer strpool.deinit(&strpool.STRINGS)
+
+    source ::
+        `empty proc() void {}
+        `grouped proc(a, b T, c U) void {
+        `    value int :: 1
+        `}
+
+    scan_state := lexer.init(mem.c_allocator)
+    defer lexer.deinit(&scan_state)
+    try lexer.scan(&scan_state, source)
+
+    parse_state := init(mem.c_allocator)
+    defer deinit(&parse_state)
+    root_id :: try parse(&parse_state, scan_state.tokens.items)
+    root :: parse_state.nodes.items[usize(root_id)]
+
+    package_start :: usize(root.data0.extra_id)
+    package_end :: usize(root.data1.extra_id)
+    try testing.expect_equal(usize(2), package_end - package_start)
+
+    empty_id :: ast.node_id(parse_state.extra.items[package_start])
+    empty :: parse_state.nodes.items[usize(empty_id)]
+    empty_payload :: usize(empty.data1.extra_id)
+    empty_block :: parse_state.nodes.items[usize(empty.data0.node_id)]
+    try testing.expect_equal(ast.NodeKind.func_decl, empty.kind)
+    try testing.expect_equal(u32(0), parse_state.extra.items[empty_payload + 1])
+    try testing.expect_equal(
+        usize(empty_block.data0.extra_id),
+        usize(empty_block.data1.extra_id),
+    )
+
+    grouped_id :: ast.node_id(parse_state.extra.items[package_start + 1])
+    grouped :: parse_state.nodes.items[usize(grouped_id)]
+    grouped_payload :: usize(grouped.data1.extra_id)
+    try testing.expect_equal(ast.NodeKind.func_decl, grouped.kind)
+    try testing.expect_equal(u32(3), parse_state.extra.items[grouped_payload + 1])
+
+    param_a_id :: ast.node_id(parse_state.extra.items[grouped_payload + 2])
+    param_b_id :: ast.node_id(parse_state.extra.items[grouped_payload + 3])
+    param_c_id :: ast.node_id(parse_state.extra.items[grouped_payload + 4])
+    param_a :: parse_state.nodes.items[usize(param_a_id)]
+    param_b :: parse_state.nodes.items[usize(param_b_id)]
+    param_c :: parse_state.nodes.items[usize(param_c_id)]
+    try testing.expect_equal(ast.NodeKind.param_decl, param_a.kind)
+    try testing.expect_equal(ast.NodeKind.param_decl, param_b.kind)
+    try testing.expect_equal(ast.NodeKind.param_decl, param_c.kind)
+    try testing.expect(param_a.data0.node_id == param_b.data0.node_id)
+    try testing.expect(param_a.data0.node_id != param_c.data0.node_id)
+
+    grouped_block :: parse_state.nodes.items[usize(grouped.data0.node_id)]
+    try testing.expect_equal(ast.NodeKind.block, grouped_block.kind)
+    try testing.expect_equal(
+        usize(1),
+        usize(grouped_block.data1.extra_id) - usize(grouped_block.data0.extra_id),
+    )
+
+    renderer := ast_renderer.init(mem.c_allocator)
+    defer ast_renderer.deinit(&renderer)
+    try ast_renderer.render_token_stream(
+        &renderer,
+        root_id,
+        &parse_state,
+        scan_state.tokens.items,
+    )
+
+    try testing.expect_equal(scan_state.tokens.items.len, renderer.tokens.items.len)
+    for scan_state.tokens.items |expected, i| {
+        actual :: renderer.tokens.items[i]
+        try testing.expect_equal(expected.kind, actual.kind)
+        try testing.expect_equal(expected.start, actual.start)
+        try testing.expect_equal(expected.str_id, actual.str_id)
+    }
+}