def try_statement_has_child_names_resolved():
_assert_children_resolved(
lambda ref: nodes.try_([nodes.expression_statement(ref)]),
)
_assert_children_resolved(
lambda ref: nodes.try_([], handlers=[
nodes.except_(None, None, [nodes.expression_statement(ref)])
]),
)
_assert_children_resolved(
lambda ref: nodes.try_([], handlers=[
nodes.except_(ref, None, [])
]),
)
_assert_children_resolved(
lambda ref: nodes.try_([], handlers=[
nodes.except_(nodes.ref("Exception"), ref, [])
]),
other_names=["Exception"],
)
_assert_children_resolved(
lambda ref: nodes.try_([], finally_body=[
nodes.expression_statement(ref)
]),
)
def test_parse_try_finally():
expected = nodes.try_(
[nodes.expression_statement(nodes.ref("x"))],
finally_body=[nodes.expression_statement(nodes.ref("y"))],
)
_assert_statement_parse(expected, "try:\n x\nfinally:\n y")
def while_loop_has_child_names_resolved():
_assert_children_resolved(
lambda ref: nodes.while_(ref, [], []),
)
_assert_children_resolved(
lambda ref: nodes.while_(nodes.bool_literal(True), [nodes.expression_statement(ref)], []),
)
_assert_children_resolved(
lambda ref: nodes.while_(nodes.bool_literal(True), [], [nodes.expression_statement(ref)]),
)
def test_parse_try_except_that_catches_all_exceptions():
expected = nodes.try_(
[nodes.expression_statement(nodes.ref("x"))],
handlers=[
nodes.except_(None, None, [
nodes.expression_statement(nodes.ref("y"))
]),
]
)
_assert_statement_parse(expected, "try:\n x\nexcept:\n y")
def test_parse_try_except_with_specific_type_and_identifier():
expected = nodes.try_(
[nodes.expression_statement(nodes.ref("x"))],
handlers=[
nodes.except_(nodes.ref("AssertionError"), "error", [
nodes.expression_statement(nodes.ref("y"))
]),
]
)
_assert_statement_parse(expected, "try:\n x\nexcept AssertionError as error:\n y")
def for_loop_has_child_names_resolved():
_assert_children_resolved(
lambda ref: nodes.for_(ref, nodes.list_literal([]), [], []),
)
_assert_children_resolved(
lambda ref: nodes.for_(nodes.ref("target"), ref, [], []),
other_names=["target"]
)
_assert_children_resolved(
lambda ref: nodes.for_(nodes.ref("target"), nodes.list_literal([]), [nodes.expression_statement(ref)], []),
other_names=["target"]
)
_assert_children_resolved(
lambda ref: nodes.for_(nodes.ref("target"), nodes.list_literal([]), [], [nodes.expression_statement(ref)]),
other_names=["target"]
)
def class_definition_bodies_can_access_variables_from_outer_scope():
ref = nodes.ref("x")
node = nodes.class_("User", [nodes.expression_statement(ref)])
declarations = _create_declarations(["x", "User"])
references = resolve(node, declarations)
assert_is(declarations.declaration("x"), references.referenced_declaration(ref))
def test_statements_in_module_body_are_transformed(self):
module_node = nodes.module([nodes.expression_statement(nodes.ref("value"))], is_executable=True)
module_type = types.module("blah", [])
_assert_transform(
module_node,
cc.module([cc.expression_statement(cc.ref("value"))], is_executable=True, exported_names=[]),
type_lookup=[(module_node, module_type)]
)
def with_statement_target_is_definitely_bound_in_body():
manager_ref = nodes.ref("manager")
target_ref = nodes.ref("target")
var_ref = nodes.ref("target")
statement = nodes.with_(manager_ref, target_ref, [nodes.expression_statement(var_ref)])
_updated_bindings(
statement,
is_definitely_bound={"manager": True},
type_lookup=TypeLookup(NodeDict([(manager_ref, context_manager_class(exit_type=types.none_type))]))
)
def function_cannot_be_referenced_before_definition():
f = nodes.func("f", type=None, args=nodes.Arguments([]), body=[])
ref_node = nodes.ref("f")
try:
_updated_bindings(nodes.module([
nodes.expression_statement(ref_node),
f,
]))
assert False, "Expected error"
except errors.UnboundLocalError as error:
assert_equal(ref_node, error.node)
def except_handler_updates_type_of_error_target():
node = nodes.try_([], handlers=[
nodes.except_(
nodes.ref("Exception"),
"error",
[nodes.expression_statement(nodes.ref("error"))]
),
])
type_bindings = {
"Exception": types.meta_type(types.exception_type)
}
context = update_context(node, type_bindings=type_bindings)
assert_equal(types.exception_type, context.lookup_name("error"))
def names_in_module_are_defined_and_resolved():
target_node = nodes.ref("x")
ref_node = nodes.ref("x")
node = nodes.module([
nodes.assign([target_node], nodes.none()),
nodes.expression_statement(ref_node),
])
declarations = _create_declarations(["x"])
references = resolve(node, declarations)
assert_is(references.referenced_declaration(ref_node), references.referenced_declaration(target_node))
def class_cannot_be_referenced_if_method_dependencies_are_not_bound():
g_ref = nodes.ref("g")
f = nodes.func("f", type=None, args=nodes.Arguments([]), body=[
nodes.ret(nodes.call(g_ref, []))
])
g = nodes.func("g", type=None, args=nodes.Arguments([]), body=[])
try:
_updated_bindings(nodes.module([
nodes.class_("a", [f]),
nodes.expression_statement(nodes.ref("a")),
g,
]))
assert False, "Expected error"
except errors.UnboundLocalError as error:
assert_equal(g_ref, error.node)
def function_cannot_be_referenced_before_definition_of_dependencies():
g_ref = nodes.ref("g")
f = nodes.func("f", type=None, args=nodes.Arguments([]), body=[
nodes.ret(nodes.call(g_ref, []))
])
g = nodes.func("g", type=None, args=nodes.Arguments([]), body=[])
try:
_updated_bindings(nodes.module([
f,
nodes.expression_statement(nodes.ref("f")),
g,
]))
assert False, "Expected error"
except errors.UnboundLocalError as error:
assert_equal(g_ref, error.node)
def test_parse_expression_statement():
expected = nodes.expression_statement(nodes.ref("x"))
_assert_statement_parse(expected, "x")
def assert_statement_is_type_checked(create_node, type_bindings=None):
assert_expression_is_type_checked(
lambda bad_expression: create_node(nodes.expression_statement(bad_expression)),
type_bindings=type_bindings,
)
def function_can_be_referenced_immediately_after_definition():
f = nodes.func("f", type=None, args=nodes.Arguments([]), body=[])
_updated_bindings(nodes.module([f, nodes.expression_statement(nodes.ref("f"))]))
def variables_from_outer_scope_remain_bound():
ref = nodes.ref("x")
func_node = nodes.func("f", nodes.arguments([]), [nodes.expression_statement(ref)], type=None)
_updated_bindings(func_node, is_definitely_bound={"x": True})
def expression_statement_has_child_names_resolved():
_assert_children_resolved(
lambda ref: nodes.expression_statement(ref),
)
def function_definitions_in_statement_lists_can_be_defined_out_of_order():
f = nodes.func("f", type=None, args=nodes.Arguments([]), body=[
nodes.ret(nodes.call(nodes.ref("g"), []))
])
g = nodes.func("g", type=None, args=nodes.Arguments([]), body=[])
_update_context([f, g, nodes.expression_statement(nodes.ref("f"))])
def arguments_of_function_are_definitely_bound():
arg = nodes.arg("x")
arg_ref = nodes.ref("x")
func_node = nodes.func("f", nodes.arguments([arg]), [nodes.expression_statement(arg_ref)], type=None)
_updated_bindings(func_node)
def unbound_ref_statement(self):
return nodes.expression_statement(self.unbound_ref())