92 lines
4.2 KiB
Plaintext
92 lines
4.2 KiB
Plaintext
import "@std/mem"
|
|
import "@std/testing"
|
|
|
|
import "@source/diagnostics"
|
|
import "@source/strpool"
|
|
import "@source/lexer"
|
|
import "@source/ast"
|
|
|
|
parses_expression_precedence_through_tree_views test {
|
|
strpool.STRINGS = strpool.init(mem.c_allocator)
|
|
defer strpool.deinit(&strpool.STRINGS)
|
|
diagnostic_store := diagnostics.init(mem.c_allocator)
|
|
defer diagnostics.deinit(&diagnostic_store)
|
|
source :: "value :: 1 + 2 * 3\n"
|
|
scan_state := lexer.init(mem.c_allocator)
|
|
defer lexer.deinit(&scan_state)
|
|
try lexer.scan(&scan_state, source, &diagnostic_store)
|
|
|
|
tree := try parse(scan_state.tokens.items, source, &diagnostic_store, mem.c_allocator)
|
|
defer ast.deinit(&tree)
|
|
|
|
try testing.expect_equal(1, ast.package_decl_count(&tree))
|
|
declaration :: ast.package_decl(&tree, 0)
|
|
statement :: ast.statement_decl(&tree, declaration)
|
|
try testing.expect_equal("value", ast.source_text(&tree, statement.name))
|
|
try testing.expect_equal(ast.ExprKind.binary, ast.expr_kind(&tree, statement.initializer))
|
|
add :: ast.binary_expr(&tree, statement.initializer)
|
|
try testing.expect_equal(ast.BinaryOperator.add, add.operator)
|
|
try testing.expect_equal(ast.ExprKind.literal_int, ast.expr_kind(&tree, add.left))
|
|
try testing.expect_equal(ast.ExprKind.binary, ast.expr_kind(&tree, add.right))
|
|
multiply :: ast.binary_expr(&tree, add.right)
|
|
try testing.expect_equal(ast.BinaryOperator.multiply, multiply.operator)
|
|
try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
|
|
}
|
|
|
|
parses_function_structure_through_tree_views test {
|
|
strpool.STRINGS = strpool.init(mem.c_allocator)
|
|
defer strpool.deinit(&strpool.STRINGS)
|
|
diagnostic_store := diagnostics.init(mem.c_allocator)
|
|
defer diagnostics.deinit(&diagnostic_store)
|
|
source ::
|
|
`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, &diagnostic_store)
|
|
|
|
tree := try parse(scan_state.tokens.items, source, &diagnostic_store, mem.c_allocator)
|
|
defer ast.deinit(&tree)
|
|
|
|
declaration :: ast.package_decl(&tree, 0)
|
|
try testing.expect_equal(ast.DeclKind.function, ast.decl_kind(&tree, declaration))
|
|
function :: ast.function_decl(&tree, declaration)
|
|
try testing.expect_equal("grouped", ast.source_text(&tree, function.name))
|
|
try testing.expect_equal(3, ast.function_param_count(&tree, declaration))
|
|
first :: ast.param(&tree, ast.function_param(&tree, declaration, 0))
|
|
second :: ast.param(&tree, ast.function_param(&tree, declaration, 1))
|
|
third :: ast.param(&tree, ast.function_param(&tree, declaration, 2))
|
|
try testing.expect_equal("a", ast.source_text(&tree, first.name))
|
|
try testing.expect_equal("b", ast.source_text(&tree, second.name))
|
|
try testing.expect_equal("c", ast.source_text(&tree, third.name))
|
|
try testing.expect_equal(first.type, second.type)
|
|
try testing.expect(first.type != third.type)
|
|
try testing.expect_equal(1, ast.block_statement_count(&tree, function.body))
|
|
try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
|
|
}
|
|
|
|
recovers_invalid_declaration_and_preserves_sibling test {
|
|
strpool.STRINGS = strpool.init(mem.c_allocator)
|
|
defer strpool.deinit(&strpool.STRINGS)
|
|
diagnostic_store := diagnostics.init(mem.c_allocator)
|
|
defer diagnostics.deinit(&diagnostic_store)
|
|
source :: "@ broken\nvalid :: 1\n"
|
|
scan_state := lexer.init(mem.c_allocator)
|
|
defer lexer.deinit(&scan_state)
|
|
try lexer.scan(&scan_state, source, &diagnostic_store)
|
|
|
|
tree := try parse(scan_state.tokens.items, source, &diagnostic_store, mem.c_allocator)
|
|
defer ast.deinit(&tree)
|
|
|
|
try testing.expect_equal(2, ast.package_decl_count(&tree))
|
|
invalid_decl :: ast.package_decl(&tree, 0)
|
|
valid_decl :: ast.package_decl(&tree, 1)
|
|
try testing.expect_equal(ast.DeclKind.invalid, ast.decl_kind(&tree, invalid_decl))
|
|
try testing.expect_equal(ast.DeclKind.statement, ast.decl_kind(&tree, valid_decl))
|
|
invalid_view :: ast.invalid(&tree, invalid_decl)
|
|
try testing.expect(diagnostics.get(&diagnostic_store, invalid_view.diagnostic) != null)
|
|
valid_statement :: ast.statement_decl(&tree, valid_decl)
|
|
try testing.expect_equal("valid", ast.source_text(&tree, valid_statement.name))
|
|
}
|