606 lines
30 KiB
Plaintext
606 lines
30 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))
|
|
}
|
|
|
|
resolves_loop_assignments_in_lexical_scopes_with_forward_local_bindings 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 ::
|
|
`main proc(flag bool) void {
|
|
` outer := 2
|
|
` while flag {
|
|
` later = outer
|
|
` later := 1
|
|
` while later > 0 {
|
|
` outer = later
|
|
` inner := later
|
|
` }
|
|
` inner
|
|
` }
|
|
` while flag { later := 3 }
|
|
` later = unknown_rhs
|
|
` while flag {
|
|
` outer := 1
|
|
` outer = 2
|
|
` bool := false
|
|
` }
|
|
`}
|
|
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)
|
|
body :: ast.function_decl(&tree, function).body
|
|
flag :: ast.function_param(&tree, function, 0)
|
|
outer :: ast.block_statement(&tree, body, 0)
|
|
first :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 1))
|
|
try testing.expect_equal(flag, binding(&resolution, first.condition).data.declaration)
|
|
forward :: ast.assignment_stmt(&tree, ast.block_statement(&tree, first.body, 0))
|
|
later :: ast.block_statement(&tree, first.body, 1)
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, forward.target).kind)
|
|
try testing.expect_equal(later, binding(&resolution, forward.target).data.declaration)
|
|
try testing.expect_equal(outer, binding(&resolution, forward.value).data.declaration)
|
|
nested :: ast.while_stmt(&tree, ast.block_statement(&tree, first.body, 2))
|
|
guard :: ast.binary_expr(&tree, nested.condition)
|
|
try testing.expect_equal(later, binding(&resolution, guard.left).data.declaration)
|
|
update :: ast.assignment_stmt(&tree, ast.block_statement(&tree, nested.body, 0))
|
|
try testing.expect_equal(outer, binding(&resolution, update.target).data.declaration)
|
|
try testing.expect_equal(later, binding(&resolution, update.value).data.declaration)
|
|
inner :: ast.block_statement(&tree, nested.body, 1)
|
|
try testing.expect_equal(later, binding(&resolution, ast.statement_decl(&tree, inner).initializer).data.declaration)
|
|
escaped_inner :: ast.statement_expr(&tree, ast.block_statement(&tree, first.body, 3))
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, escaped_inner).kind)
|
|
sibling :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 2))
|
|
sibling_local :: ast.block_statement(&tree, sibling.body, 0)
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, sibling_local).kind)
|
|
try testing.expect(sibling_local != later)
|
|
escaped :: ast.assignment_stmt(&tree, ast.block_statement(&tree, body, 3))
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, escaped.target).kind)
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, escaped.value).kind)
|
|
try testing.expect(binding(&resolution, escaped.target).data.diagnostic != binding(&resolution, escaped.value).data.diagnostic)
|
|
forbidden :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 4))
|
|
shadow :: ast.block_statement(&tree, forbidden.body, 0)
|
|
poisoned :: ast.assignment_stmt(&tree, ast.block_statement(&tree, forbidden.body, 1))
|
|
builtin :: ast.block_statement(&tree, forbidden.body, 2)
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, shadow).kind)
|
|
try testing.expect_equal(binding(&resolution, shadow).data.diagnostic, binding(&resolution, poisoned.target).data.diagnostic)
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, builtin).kind)
|
|
try testing.expect_equal(5, diagnostics.count(&diagnostic_store))
|
|
}
|
|
|
|
resolves_all_code_and_preserves_scopes_after_loop_controls 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 ::
|
|
`main proc() void {
|
|
` while (true) {
|
|
` break
|
|
` before :: later
|
|
` continue
|
|
` later :: 1
|
|
` missing_after_break
|
|
` if (true) {
|
|
` continue
|
|
` private :: later
|
|
` int :: 2
|
|
` }
|
|
` private
|
|
` }
|
|
` later
|
|
`}
|
|
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)
|
|
try testing.expect_equal(4, diagnostics.count(&diagnostic_store))
|
|
body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
|
|
loop :: ast.while_stmt(&tree, ast.block_statement(&tree, body, 0))
|
|
before :: ast.block_statement(&tree, loop.body, 1)
|
|
later :: ast.block_statement(&tree, loop.body, 3)
|
|
reference :: ast.statement_decl(&tree, before).initializer
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, reference).kind)
|
|
try testing.expect_equal(later, binding(&resolution, reference).data.declaration)
|
|
conditional :: ast.if_stmt(&tree, ast.block_statement(&tree, loop.body, 5))
|
|
private_decl :: ast.block_statement(&tree, conditional.then_block, 1)
|
|
private_ref :: ast.statement_decl(&tree, private_decl).initializer
|
|
try testing.expect_equal(later, binding(&resolution, private_ref).data.declaration)
|
|
forbidden :: ast.block_statement(&tree, conditional.then_block, 2)
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, forbidden).kind)
|
|
}
|
|
|
|
range_bounds_use_outer_scope_and_captures_are_body_declarations 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 ::
|
|
`run proc() void {
|
|
` for lower..upper |item| {
|
|
` before :: later
|
|
` later :: item
|
|
` continue
|
|
` item
|
|
` }
|
|
` for lower..upper |item| { item }
|
|
` lower :: 0
|
|
` upper :: 2
|
|
` item
|
|
`}
|
|
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)
|
|
body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
|
|
loop :: ast.for_stmt(&tree, ast.block_statement(&tree, body, 0))
|
|
sibling :: ast.for_stmt(&tree, ast.block_statement(&tree, body, 1))
|
|
lower :: ast.block_statement(&tree, body, 2)
|
|
upper :: ast.block_statement(&tree, body, 3)
|
|
bounds :: ast.range_expr(&tree, loop.iterable)
|
|
try testing.expect_equal(lower, binding(&resolution, bounds.start).data.declaration)
|
|
try testing.expect_equal(upper, binding(&resolution, bounds.end).data.declaration)
|
|
if (loop.capture) |capture| {
|
|
try testing.expect_equal(capture, binding(&resolution, capture).data.declaration)
|
|
later :: ast.block_statement(&tree, loop.body, 1)
|
|
before_ref :: ast.statement_decl(&tree, ast.block_statement(&tree, loop.body, 0)).initializer
|
|
try testing.expect_equal(later, binding(&resolution, before_ref).data.declaration)
|
|
capture_ref :: ast.statement_decl(&tree, later).initializer
|
|
try testing.expect_equal(capture, binding(&resolution, capture_ref).data.declaration)
|
|
dead_ref :: ast.statement_expr(&tree, ast.block_statement(&tree, loop.body, 3))
|
|
try testing.expect_equal(capture, binding(&resolution, dead_ref).data.declaration)
|
|
} else return .expectation_failed
|
|
if (sibling.capture) |capture| {
|
|
try testing.expect_equal(BindingKind.declaration, binding(&resolution, capture).kind)
|
|
sibling_ref :: ast.statement_expr(&tree, ast.block_statement(&tree, sibling.body, 0))
|
|
try testing.expect_equal(capture, binding(&resolution, sibling_ref).data.declaration)
|
|
} else return .expectation_failed
|
|
escaped :: ast.statement_expr(&tree, ast.block_statement(&tree, body, 4))
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, escaped).kind)
|
|
try testing.expect_equal(1, diagnostics.count(&diagnostic_store))
|
|
}
|
|
|
|
range_captures_preserve_duplicate_builtin_and_discard_errors 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 ::
|
|
`run proc() void {
|
|
` outer :: 0
|
|
` for outer..2 |outer| { outer }
|
|
` for 0..2 |int| { int }
|
|
` for 0..2 |item, item| { item }
|
|
` for 0..2 |local| {
|
|
` local :: 1
|
|
` local
|
|
` }
|
|
` for 0..2 |_| {
|
|
` break
|
|
` _
|
|
` missing
|
|
` }
|
|
` for missing_start..missing_end |i| {}
|
|
`}
|
|
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)
|
|
body :: ast.function_decl(&tree, ast.package_decl(&tree, 0)).body
|
|
for (usize(1)..usize(3)) |index| {
|
|
loop :: ast.for_stmt(&tree, ast.block_statement(&tree, body, index))
|
|
if (loop.capture) |capture| {
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, capture).kind)
|
|
reference :: ast.statement_expr(&tree, ast.block_statement(&tree, loop.body, 0))
|
|
try testing.expect_equal(
|
|
binding(&resolution, capture).data.diagnostic,
|
|
binding(&resolution, reference).data.diagnostic,
|
|
)
|
|
} else return .expectation_failed
|
|
}
|
|
indexed :: ast.for_stmt(&tree, ast.block_statement(&tree, body, 3))
|
|
if (indexed.index) |index| {
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, index).kind)
|
|
} else return .expectation_failed
|
|
if (indexed.capture) |capture| {
|
|
reference :: ast.statement_expr(&tree, ast.block_statement(&tree, indexed.body, 0))
|
|
try testing.expect_equal(capture, binding(&resolution, reference).data.declaration)
|
|
} else return .expectation_failed
|
|
local_loop :: ast.for_stmt(&tree, ast.block_statement(&tree, body, 4))
|
|
duplicate :: ast.block_statement(&tree, local_loop.body, 0)
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, duplicate).kind)
|
|
discard :: ast.for_stmt(&tree, ast.block_statement(&tree, body, 5))
|
|
try testing.expect(discard.capture == null)
|
|
for (usize(1)..usize(3)) |index| {
|
|
reference :: ast.statement_expr(&tree, ast.block_statement(&tree, discard.body, index))
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, reference).kind)
|
|
}
|
|
missing_loop :: ast.for_stmt(&tree, ast.block_statement(&tree, body, 6))
|
|
bounds :: ast.range_expr(&tree, missing_loop.iterable)
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, bounds.start).kind)
|
|
try testing.expect_equal(BindingKind.invalid, binding(&resolution, bounds.end).kind)
|
|
try testing.expect_equal(8, diagnostics.count(&diagnostic_store))
|
|
}
|