/* * Copyright (C) 2023 Carlos Maniero * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #define MUNIT_ENABLE_ASSERT_ALIASES #include "ast.h" #include "lexer.h" #include "munit.h" #include "parser.h" #include "scope.h" #include "string.h" #include "vector.h" void assert_string_view_equal(char *expected, string_view_t actual); void make_lexer_from_static_src(lexer_t *lexer, char *src) { lexer->filepath = "test.pipa"; lexer->srclen = 0; lexer->cur = 0; lexer->row = 0; lexer->bol = 0; lexer->src = src; lexer->srclen = strlen(src); } void assert_parser_error(char *src, char *error_msg) { parser_t parser; lexer_t lexer; scope_t *scope = scope_new(); make_lexer_from_static_src(&lexer, src); parser_init(&parser, &lexer, scope); ast_node_t *ast_function = parser_parse_function_declaration(&parser); assert_false(ast_function != NULL); assert_int(1, ==, parser.errors_len); assert_string_equal(error_msg, parser.errors[0].message); scope_destroy(scope); } static MunitResult test_parse_function(const MunitParameter params[], void *user_data_or_fixture) { parser_t parser; lexer_t lexer; scope_t *scope = scope_new(); make_lexer_from_static_src(&lexer, "fn main(): i32 { \nreturn 42;\n }"); parser_init(&parser, &lexer, scope); ast_node_t *ast_function = parser_parse_function_declaration(&parser); assert_not_null(ast_function); char actual[5]; string_view_to_str(&ast_function->data.function.identifier.name, actual); assert_string_equal("main", actual); assert_int(AST_FUNCTION_DECLARATION, ==, ast_function->kind); ast_node_t *ast_return = vector_at(ast_function->data.function.body, 0); assert_int(AST_RETURN_STMT, ==, ast_return->kind); ast_node_t *ast_literal = ast_return->data.return_stmt.argument; assert_int(AST_LITERAL, ==, ast_literal->kind); assert_int(42, ==, ast_literal->data.literal.value.integer); ast_node_destroy(ast_function); scope_destroy(scope); return MUNIT_OK; } static MunitResult test_parse_variable_definition(const MunitParameter params[], void *user_data_or_fixture) { parser_t parser; lexer_t lexer; scope_t *scope = scope_new(); make_lexer_from_static_src(&lexer, "fn main(): i32 { \nlet variable: i32 = 42; \nreturn variable;\n }"); parser_init(&parser, &lexer, scope); ast_node_t *ast_function = parser_parse_function_declaration(&parser); assert_true(ast_function != NULL); char actual[5]; string_view_to_str(&ast_function->data.function.identifier.name, actual); assert_string_equal("main", actual); assert_int(AST_FUNCTION_DECLARATION, ==, ast_function->kind); ast_node_t *ast_variable = vector_at(ast_function->data.function.body, 0); assert_int(AST_VARIABLE_DECLARATION, ==, ast_variable->kind); assert_string_view_equal("variable", ast_variable->data.variable_declaration.identifier.name); ast_node_t *ast_return = vector_at(ast_function->data.function.body, 1); assert_int(AST_RETURN_STMT, ==, ast_return->kind); ast_node_t *ast_literal = ast_return->data.return_stmt.argument; assert_int(AST_VARIABLE, ==, ast_literal->kind); assert_string_view_equal("variable", ast_literal->data.variable.identifier->name); ast_node_destroy(ast_function); scope_destroy(scope); return MUNIT_OK; } static MunitResult test_parse_boolean(const MunitParameter params[], void *user_data_or_fixture) { parser_t parser; lexer_t lexer; scope_t *scope = scope_new(); make_lexer_from_static_src(&lexer, "fn my_bool_fn(): bool { \nlet variable: bool = true; \nreturn variable;\n }"); parser_init(&parser, &lexer, scope); ast_node_t *ast_function = parser_parse_function_declaration(&parser); assert_true(ast_function != NULL); assert_string_view_equal("my_bool_fn", ast_function->data.function.identifier.name); assert_int(AST_FUNCTION_DECLARATION, ==, ast_function->kind); ast_node_t *ast_variable = vector_at(ast_function->data.function.body, 0); assert_int(AST_VARIABLE_DECLARATION, ==, ast_variable->kind); assert_string_view_equal("variable", ast_variable->data.variable_declaration.identifier.name); assert_int(TYPE_BOOL, ==, ast_variable->data.variable_declaration.type); assert_int(AST_LITERAL, ==, ast_variable->data.variable_declaration.value->kind); assert_int(AST_LITERAL_BOOL, ==, ast_variable->data.variable_declaration.value->data.literal.kind); assert_true(ast_variable->data.variable_declaration.value->data.literal.value.boolean); ast_node_t *ast_return = vector_at(ast_function->data.function.body, 1); assert_int(AST_RETURN_STMT, ==, ast_return->kind); ast_node_t *ast_literal = ast_return->data.return_stmt.argument; assert_int(AST_VARIABLE, ==, ast_literal->kind); assert_string_view_equal("variable", ast_literal->data.variable.identifier->name); ast_node_destroy(ast_function); scope_destroy(scope); scope = scope_new(); make_lexer_from_static_src(&lexer, "fn my_bool_fn(): bool { \nlet variable: bool = false; \nreturn variable;\n }"); parser_init(&parser, &lexer, scope); ast_function = parser_parse_function_declaration(&parser); assert_true(ast_function != NULL); ast_node_destroy(ast_function); scope_destroy(scope); return MUNIT_OK; } static MunitResult test_parse_arithmetic_expression(const MunitParameter params[], void *user_data_or_fixture) { parser_t parser; lexer_t lexer; scope_t *scope = scope_new(); make_lexer_from_static_src(&lexer, "1 + 3 * 3 / 2 - 1"); parser_init(&parser, &lexer, scope); ast_node_t *ast_expression = parser_parse_expression(&parser); assert_not_null(ast_expression); ast_node_t *exp1 = ast_expression; { assert_int(AST_BINARY_OPERATION, ==, exp1->kind); assert_int(AST_BINARY_OPERATION, ==, exp1->kind); assert_int(AST_BINOP_SUBTRACTION, ==, exp1->data.binary_operation.kind); ast_node_t *exp2 = exp1->data.binary_operation.left; { assert_int(AST_BINARY_OPERATION, ==, exp2->kind); assert_int(AST_BINOP_ADITION, ==, exp2->data.binary_operation.kind); assert_int(AST_LITERAL, ==, exp2->data.binary_operation.left->kind); assert_int(exp2->data.binary_operation.left->data.literal.value.integer, ==, 1); ast_node_t *exp3 = exp2->data.binary_operation.right; { assert_int(AST_BINARY_OPERATION, ==, exp3->kind); assert_int(AST_BINOP_DIVISION, ==, exp3->data.binary_operation.kind); ast_node_t *exp4 = exp3->data.binary_operation.left; { assert_int(AST_BINARY_OPERATION, ==, exp4->kind); assert_int(AST_BINOP_MULTIPLICATION, ==, exp4->data.binary_operation.kind); assert_int(AST_LITERAL, ==, exp4->data.binary_operation.left->kind); assert_int(exp4->data.binary_operation.left->data.literal.value.integer, ==, 3); assert_int(AST_LITERAL, ==, exp4->data.binary_operation.right->kind); assert_int(exp4->data.binary_operation.right->data.literal.value.integer, ==, 3); } assert_int(AST_LITERAL, ==, exp3->data.binary_operation.right->kind); assert_int(exp3->data.binary_operation.right->data.literal.value.integer, ==, 2); } } assert_int(AST_LITERAL, ==, exp1->data.binary_operation.right->kind); assert_int(exp1->data.binary_operation.right->data.literal.value.integer, ==, 1); } ast_node_destroy(ast_expression); scope_destroy(scope); return MUNIT_OK; } void assert_string_view_equal(char *expected, string_view_t actual) { size_t expected_len = strlen(expected); assert_int(expected_len, ==, actual.size); assert_memory_equal(expected_len, expected, actual.str); } static MunitResult test_parse_basic_syntax_errors(const MunitParameter params[], void *user_data_or_fixture) { assert_parser_error("main(): i32 { return 42; }", "expected 'fn' but got 'TOKEN_NAME'"); assert_parser_error("fn (): i32 { return 42; }", "expected 'TOKEN_NAME' but got '('"); assert_parser_error("fn main): i32 { return 42; }", "expected '(' but got ')'"); assert_parser_error("fn main(: i32 { return 42; }", "expected ')' but got ':'"); assert_parser_error("fn main() i32 { return 42; }", "expected ':' but got 'TOKEN_NAME'"); assert_parser_error("fn main(): { return 42; }", "expected 'TOKEN_NAME' but got '{'"); assert_parser_error("fn main(): i32 return 42; }", "expected '{' but got 'return'"); assert_parser_error("fn main(): i32 { 42; }", "unexpected token 'TOKEN_NUMBER' value='42'"); assert_parser_error("fn main(): i32 { return; }", "unexpected '; (;)' token"); assert_parser_error("fn main(): i32 { return 42;", "expected '}' but got end of file"); assert_parser_error("fn main(): beff { return 42; }", "type 'beff' is not defined"); assert_parser_error("fn main(): i32 { return b; }", "identifier 'b' not defined"); assert_parser_error("fn main(): i32 { b = 1; return b; }", "trying to assign 'b' before defining it."); // FIXME: once function calls are implemented, this error should inform that // neither a variable or function call was found. assert_parser_error("fn main(): i32 { oxi 42; }", "unexpected token 'TOKEN_NAME' value='oxi'"); return MUNIT_OK; } static MunitTest tests[] = { { "/test_parse_function", test_parse_function, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }, { "/test_parse_boolean", test_parse_boolean, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }, { "/test_parse_basic_syntax_errors", test_parse_basic_syntax_errors, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }, { "/test_parse_arithmetic_expression", test_parse_arithmetic_expression, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }, { "/test_parse_variable_definition", test_parse_variable_definition, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }, { NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL } }; static const MunitSuite suite = { "/parser", tests, NULL, 1, MUNIT_SUITE_OPTION_NONE }; int main(int argc, char *argv[]) { return munit_suite_main(&suite, NULL, argc, argv); return EXIT_SUCCESS; }