hl-valdemar
9932750e21
Use typed singleton arrays for braceless arm blocks: &[statement] compiled but trapped under the Bro bootstrap.
369 lines
18 KiB
Plaintext
369 lines
18 KiB
Plaintext
import "@std/mem"
|
|
import "@std/testing"
|
|
|
|
import "@source/diagnostics"
|
|
import "@source/strpool"
|
|
import "@source/lexer"
|
|
import "@source/parser"
|
|
import "@source/ast"
|
|
|
|
resolves_forward_references_recursion_and_builtin_signatures 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 ::
|
|
`first :: later
|
|
`alpha proc(p int, q float, s string) void {
|
|
` before :: -after * p + beta(after)
|
|
` after :: later
|
|
`}
|
|
`beta proc(p int) void {
|
|
` after :: p
|
|
` alpha(after, 1.0, "x")
|
|
`}
|
|
`later int :: 1
|
|
scan_state := lexer.init(mem.c_allocator)
|
|
defer lexer.deinit(&scan_state)
|
|
try lexer.scan(&scan_state, source, &diagnostic_store)
|
|
tree := try parser.parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
|
|
defer ast.deinit(&tree)
|
|
resolution := try resolve(mem.c_allocator, &tree, &diagnostic_store)
|
|
defer deinit(&resolution)
|
|
|
|
first :: ast.package_decl(&tree, 0)
|
|
alpha :: ast.package_decl(&tree, 1)
|
|
beta :: ast.package_decl(&tree, 2)
|
|
later :: ast.package_decl(&tree, 3)
|
|
alpha_view :: ast.function_decl(&tree, alpha)
|
|
beta_view :: ast.function_decl(&tree, beta)
|
|
before :: ast.block_statement(&tree, alpha_view.body, 0)
|
|
after :: ast.block_statement(&tree, alpha_view.body, 1)
|
|
p :: ast.function_param(&tree, alpha, 0)
|
|
q :: ast.function_param(&tree, alpha, 1)
|
|
s :: ast.function_param(&tree, alpha, 2)
|
|
sibling_p :: ast.function_param(&tree, beta, 0)
|
|
sibling_after :: ast.block_statement(&tree, beta_view.body, 0)
|
|
first_ref :: ast.statement_decl(&tree, first).initializer
|
|
after_ref :: ast.statement_decl(&tree, after).initializer
|
|
references [2]ast.NodeId :: [first_ref, after_ref]
|
|
for references |id| {
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, id).kind)
|
|
try testing.expect_equal(later, binding(&resolution, id).data.declaration)
|
|
}
|
|
add :: ast.binary_expr(&tree, ast.statement_decl(&tree, before).initializer)
|
|
multiply :: ast.binary_expr(&tree, add.left)
|
|
forward_ref :: ast.unary_expr(&tree, multiply.left).operand
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, forward_ref).kind)
|
|
try testing.expect_equal(after, binding(&resolution, forward_ref).data.declaration)
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, multiply.right).kind)
|
|
try testing.expect_equal(p, binding(&resolution, multiply.right).data.declaration)
|
|
beta_ref :: ast.call_expr(&tree, add.right).callee
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, beta_ref).kind)
|
|
try testing.expect_equal(beta, binding(&resolution, beta_ref).data.declaration)
|
|
argument :: ast.call_arg(&tree, add.right, 0)
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, argument).kind)
|
|
try testing.expect_equal(after, binding(&resolution, argument).data.declaration)
|
|
recursive_call :: ast.statement_expr(&tree, ast.block_statement(&tree, beta_view.body, 1))
|
|
alpha_ref :: ast.call_expr(&tree, recursive_call).callee
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, alpha_ref).kind)
|
|
try testing.expect_equal(alpha, binding(&resolution, alpha_ref).data.declaration)
|
|
sibling_ref :: ast.call_arg(&tree, recursive_call, 0)
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, sibling_ref).kind)
|
|
try testing.expect_equal(sibling_after, binding(&resolution, sibling_ref).data.declaration)
|
|
sibling_param_ref :: ast.statement_decl(&tree, sibling_after).initializer
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, sibling_param_ref).kind)
|
|
try testing.expect_equal(sibling_p, binding(&resolution, sibling_param_ref).data.declaration)
|
|
parameter_types [2]ast.NodeId :: [ast.param(&tree, p).type, ast.param(&tree, sibling_p).type]
|
|
for parameter_types |id| {
|
|
try testing.expect_equal(BindingKind.builtin, binding(&resolution, id).kind)
|
|
try testing.expect_equal(BuiltinType.int, binding(&resolution, id).data.builtin)
|
|
}
|
|
if (ast.statement_decl(&tree, later).type) |type| {
|
|
try testing.expect_equal(BindingKind.builtin, binding(&resolution, type).kind)
|
|
try testing.expect_equal(BuiltinType.int, binding(&resolution, type).data.builtin)
|
|
} else {
|
|
return .expectation_failed
|
|
}
|
|
try testing.expect_equal(
|
|
BindingKind.builtin,
|
|
binding(&resolution, ast.param(&tree, q).type).kind,
|
|
)
|
|
try testing.expect_equal(
|
|
BuiltinType.float,
|
|
binding(&resolution, ast.param(&tree, q).type).data.builtin,
|
|
)
|
|
try testing.expect_equal(
|
|
BindingKind.builtin,
|
|
binding(&resolution, ast.param(&tree, s).type).kind,
|
|
)
|
|
try testing.expect_equal(
|
|
BuiltinType.string,
|
|
binding(&resolution, ast.param(&tree, s).type).data.builtin,
|
|
)
|
|
return_types [2]ast.NodeId :: [alpha_view.return_type, beta_view.return_type]
|
|
for return_types |id| {
|
|
try testing.expect_equal(BindingKind.builtin, binding(&resolution, id).kind)
|
|
try testing.expect_equal(BuiltinType.void, binding(&resolution, id).data.builtin)
|
|
}
|
|
try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
|
|
}
|
|
|
|
rejects_shadowing_and_duplicates_without_cascades 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 ::
|
|
`collide proc(outer int, p int, p int) outer {
|
|
` outer :: missing
|
|
` outer :: 1
|
|
` p :: 1
|
|
` int :: 1
|
|
` pkg :: 1
|
|
` outer
|
|
` p
|
|
` int
|
|
` pkg
|
|
`}
|
|
`outer :: 1
|
|
`pkg :: 1
|
|
`same :: 1
|
|
`same :: same
|
|
scan_state := lexer.init(mem.c_allocator)
|
|
defer lexer.deinit(&scan_state)
|
|
try lexer.scan(&scan_state, source, &diagnostic_store)
|
|
tree := try parser.parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
|
|
defer ast.deinit(&tree)
|
|
try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
|
|
resolution := try resolve(mem.c_allocator, &tree, &diagnostic_store)
|
|
defer deinit(&resolution)
|
|
|
|
function :: ast.package_decl(&tree, 0)
|
|
view :: ast.function_decl(&tree, function)
|
|
outer :: ast.package_decl(&tree, 1)
|
|
first_same :: ast.package_decl(&tree, 3)
|
|
second_same :: ast.package_decl(&tree, 4)
|
|
outer_param :: ast.function_param(&tree, function, 0)
|
|
p :: ast.function_param(&tree, function, 1)
|
|
duplicate_p :: ast.function_param(&tree, function, 2)
|
|
first_outer :: ast.block_statement(&tree, view.body, 0)
|
|
second_outer :: ast.block_statement(&tree, view.body, 1)
|
|
local_p :: ast.block_statement(&tree, view.body, 2)
|
|
local_int :: ast.block_statement(&tree, view.body, 3)
|
|
local_pkg :: ast.block_statement(&tree, view.body, 4)
|
|
rejected [8]ast.NodeId :: [
|
|
outer_param,
|
|
duplicate_p,
|
|
first_outer,
|
|
second_outer,
|
|
local_p,
|
|
local_int,
|
|
local_pkg,
|
|
second_same,
|
|
]
|
|
for rejected |id| {
|
|
invalid_binding :: binding(&resolution, id)
|
|
try testing.expect_equal(BindingKind.invalid, invalid_binding.kind)
|
|
if (diagnostics.get(&diagnostic_store, invalid_binding.data.diagnostic)) |diagnostic| {
|
|
try testing.expect_equal(diagnostics.Code.duplicate_name, diagnostic.code)
|
|
name :: if (id == outer_param or id == duplicate_p)
|
|
ast.param(&tree, id).name
|
|
else
|
|
ast.statement_decl(&tree, id).name
|
|
try testing.expect_equal(name.start, diagnostic.span.start)
|
|
try testing.expect_equal(name.end, diagnostic.span.end)
|
|
} else {
|
|
return .expectation_failed
|
|
}
|
|
}
|
|
try testing.expect(
|
|
binding(&resolution, first_outer).data.diagnostic != binding(&resolution, second_outer).data.diagnostic,
|
|
)
|
|
try testing.expect(
|
|
binding(&resolution, outer_param).data.diagnostic != binding(&resolution, first_outer).data.diagnostic,
|
|
)
|
|
try testing.expect(
|
|
binding(&resolution, duplicate_p).data.diagnostic != binding(&resolution, local_p).data.diagnostic,
|
|
)
|
|
outer_ref :: ast.statement_expr(&tree, ast.block_statement(&tree, view.body, 5))
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, outer_ref).kind)
|
|
try testing.expect_equal(
|
|
binding(&resolution, outer_param).data.diagnostic,
|
|
binding(&resolution, outer_ref).data.diagnostic,
|
|
)
|
|
p_ref :: ast.statement_expr(&tree, ast.block_statement(&tree, view.body, 6))
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, p_ref).kind)
|
|
try testing.expect_equal(p, binding(&resolution, p_ref).data.declaration)
|
|
int_ref :: ast.statement_expr(&tree, ast.block_statement(&tree, view.body, 7))
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, int_ref).kind)
|
|
try testing.expect_equal(
|
|
binding(&resolution, local_int).data.diagnostic,
|
|
binding(&resolution, int_ref).data.diagnostic,
|
|
)
|
|
pkg_ref :: ast.statement_expr(&tree, ast.block_statement(&tree, view.body, 8))
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, pkg_ref).kind)
|
|
try testing.expect_equal(
|
|
binding(&resolution, local_pkg).data.diagnostic,
|
|
binding(&resolution, pkg_ref).data.diagnostic,
|
|
)
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, view.return_type).kind)
|
|
try testing.expect_equal(outer, binding(&resolution, view.return_type).data.declaration)
|
|
parameter_type :: ast.param(&tree, outer_param).type
|
|
try testing.expect_equal(BindingKind.builtin, binding(&resolution, parameter_type).kind)
|
|
try testing.expect_equal(BuiltinType.int, binding(&resolution, parameter_type).data.builtin)
|
|
same_ref :: ast.statement_decl(&tree, second_same).initializer
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, same_ref).kind)
|
|
try testing.expect_equal(first_same, binding(&resolution, same_ref).data.declaration)
|
|
missing :: ast.statement_decl(&tree, first_outer).initializer
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, missing).kind)
|
|
if (diagnostics.get(&diagnostic_store, binding(&resolution, missing).data.diagnostic)) |diagnostic| {
|
|
try testing.expect_equal(diagnostics.Code.unknown_name, diagnostic.code)
|
|
try testing.expect_equal(ast.node_span(&tree, missing).start, diagnostic.span.start)
|
|
try testing.expect_equal(ast.node_span(&tree, missing).end, diagnostic.span.end)
|
|
} else {
|
|
return .expectation_failed
|
|
}
|
|
try testing.expect_equal(9, diagnostics.count(&diagnostic_store))
|
|
}
|
|
|
|
preserves_syntax_diagnostics_and_resolves_shared_unknown_types_once 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
|
|
`main proc(a, b Missing) void {
|
|
` empty :: ()
|
|
` bad :: absent + absent
|
|
` valid :: later
|
|
` later :: 1
|
|
` discarded(1 2)
|
|
`}
|
|
scan_state := lexer.init(mem.c_allocator)
|
|
defer lexer.deinit(&scan_state)
|
|
try lexer.scan(&scan_state, source, &diagnostic_store)
|
|
tree := try parser.parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
|
|
defer ast.deinit(&tree)
|
|
syntax_count :: diagnostics.count(&diagnostic_store)
|
|
invalid_decl :: ast.package_decl(&tree, 0)
|
|
try testing.expect_equal(ast.DeclKind.invalid, ast.decl_kind(&tree, invalid_decl))
|
|
function :: ast.package_decl(&tree, 1)
|
|
view :: ast.function_decl(&tree, function)
|
|
empty :: ast.statement_decl(&tree, ast.block_statement(&tree, view.body, 0)).initializer
|
|
try testing.expect_equal(ast.ExprKind.invalid, ast.expr_kind(&tree, empty))
|
|
invalid_statement :: ast.block_statement(&tree, view.body, 4)
|
|
try testing.expect_equal(ast.StmtKind.invalid, ast.stmt_kind(&tree, invalid_statement))
|
|
resolution := try resolve(mem.c_allocator, &tree, &diagnostic_store)
|
|
defer deinit(&resolution)
|
|
|
|
invalid_nodes [3]ast.NodeId :: [invalid_decl, empty, invalid_statement]
|
|
for invalid_nodes |id| {
|
|
invalid_view :: ast.invalid(&tree, id)
|
|
invalid_binding :: binding(&resolution, id)
|
|
try testing.expect_equal(BindingKind.invalid, invalid_binding.kind)
|
|
try testing.expect_equal(invalid_view.diagnostic, invalid_binding.data.diagnostic)
|
|
}
|
|
a :: ast.function_param(&tree, function, 0)
|
|
b :: ast.function_param(&tree, function, 1)
|
|
shared_type :: ast.param(&tree, a).type
|
|
try testing.expect_equal(
|
|
binding(&resolution, shared_type).data.diagnostic,
|
|
binding(&resolution, ast.param(&tree, b).type).data.diagnostic,
|
|
)
|
|
bad :: ast.binary_expr(
|
|
&tree,
|
|
ast.statement_decl(&tree, ast.block_statement(&tree, view.body, 1)).initializer,
|
|
)
|
|
unknown_nodes [3]ast.NodeId :: [shared_type, bad.left, bad.right]
|
|
for unknown_nodes |id| {
|
|
invalid_binding :: binding(&resolution, id)
|
|
try testing.expect_equal(BindingKind.invalid, invalid_binding.kind)
|
|
if (diagnostics.get(&diagnostic_store, invalid_binding.data.diagnostic)) |diagnostic| {
|
|
try testing.expect_equal(diagnostics.Code.unknown_name, diagnostic.code)
|
|
try testing.expect_equal(ast.node_span(&tree, id).start, diagnostic.span.start)
|
|
try testing.expect_equal(ast.node_span(&tree, id).end, diagnostic.span.end)
|
|
} else {
|
|
return .expectation_failed
|
|
}
|
|
}
|
|
try testing.expect(
|
|
binding(&resolution, bad.left).data.diagnostic != binding(&resolution, bad.right).data.diagnostic,
|
|
)
|
|
valid :: ast.block_statement(&tree, view.body, 2)
|
|
later :: ast.block_statement(&tree, view.body, 3)
|
|
valid_ref :: ast.statement_decl(&tree, valid).initializer
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, valid_ref).kind)
|
|
try testing.expect_equal(later, binding(&resolution, valid_ref).data.declaration)
|
|
try testing.expect_equal(syntax_count + 3, diagnostics.count(&diagnostic_store))
|
|
}
|
|
|
|
resolves_conditional_arm_scopes_without_leaks_or_shadowing 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 ::
|
|
`choose proc(flag bool, value int) void {
|
|
` if flag {
|
|
` before :: later
|
|
` later :: value
|
|
` if before == value { nested :: later }
|
|
` } else {
|
|
` later :: value
|
|
` }
|
|
` later
|
|
` if later { later :: 1 }
|
|
` if flag {
|
|
` value :: 2
|
|
` bool :: false
|
|
` if flag { value }
|
|
` }
|
|
`}
|
|
scan_state := lexer.init(mem.c_allocator)
|
|
defer lexer.deinit(&scan_state)
|
|
try lexer.scan(&scan_state, source, &diagnostic_store)
|
|
tree := try parser.parse(mem.c_allocator, scan_state.tokens.items, source, &diagnostic_store)
|
|
defer ast.deinit(&tree)
|
|
try testing.expect_equal(0, diagnostics.count(&diagnostic_store))
|
|
resolution := try resolve(mem.c_allocator, &tree, &diagnostic_store)
|
|
defer deinit(&resolution)
|
|
|
|
function :: ast.package_decl(&tree, 0)
|
|
view :: ast.function_decl(&tree, function)
|
|
flag :: ast.function_param(&tree, function, 0)
|
|
value :: ast.function_param(&tree, function, 1)
|
|
try testing.expect_equal(BuiltinType.bool, binding(&resolution, ast.param(&tree, flag).type).data.builtin)
|
|
first :: ast.if_stmt(&tree, ast.block_statement(&tree, view.body, 0))
|
|
try testing.expect_equal(flag, binding(&resolution, first.condition).data.declaration)
|
|
before :: ast.block_statement(&tree, first.then_block, 0)
|
|
later :: ast.block_statement(&tree, first.then_block, 1)
|
|
try testing.expect_equal(later, binding(&resolution, ast.statement_decl(&tree, before).initializer).data.declaration)
|
|
try testing.expect_equal(value, binding(&resolution, ast.statement_decl(&tree, later).initializer).data.declaration)
|
|
nested :: ast.if_stmt(&tree, ast.block_statement(&tree, first.then_block, 2))
|
|
nested_decl :: ast.block_statement(&tree, nested.then_block, 0)
|
|
try testing.expect_equal(later, binding(&resolution, ast.statement_decl(&tree, nested_decl).initializer).data.declaration)
|
|
if (first.else_block) |other| {
|
|
sibling :: ast.block_statement(&tree, other, 0)
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, sibling).kind)
|
|
try testing.expect_equal(sibling, binding(&resolution, sibling).data.declaration)
|
|
} else {
|
|
return .expectation_failed
|
|
}
|
|
outside :: ast.statement_expr(&tree, ast.block_statement(&tree, view.body, 1))
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, outside).kind)
|
|
independent :: ast.if_stmt(&tree, ast.block_statement(&tree, view.body, 2))
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, independent.condition).kind)
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, ast.block_statement(&tree, independent.then_block, 0)).kind)
|
|
forbidden :: ast.if_stmt(&tree, ast.block_statement(&tree, view.body, 3))
|
|
shadow :: ast.block_statement(&tree, forbidden.then_block, 0)
|
|
builtin :: ast.block_statement(&tree, forbidden.then_block, 1)
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, shadow).kind)
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, builtin).kind)
|
|
poisoned :: ast.if_stmt(&tree, ast.block_statement(&tree, forbidden.then_block, 2))
|
|
use :: ast.statement_expr(&tree, ast.block_statement(&tree, poisoned.then_block, 0))
|
|
try testing.expect_equal(binding(&resolution, shadow).data.diagnostic, binding(&resolution, use).data.diagnostic)
|
|
try testing.expect_equal(4, diagnostics.count(&diagnostic_store))
|
|
}
|