def declarations_in_exactly_one_if_else_branch_are_not_definitely_bound():
_assert_name_is_not_definitely_bound(lambda generate:
nodes.if_(nodes.bool_literal(True), [generate.assignment()], [])
)
_assert_name_is_not_definitely_bound(lambda generate:
nodes.if_(nodes.bool_literal(True), [], [generate.assignment()])
)
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 assert_statement_has_child_names_resolved():
_assert_children_resolved(
lambda ref: nodes.assert_(ref),
)
_assert_children_resolved(
lambda ref: nodes.assert_(nodes.bool_literal(False), ref),
)
def break_is_not_valid_in_while_loop_else_body():
break_node = nodes.break_()
node = nodes.while_(nodes.bool_literal(True), [], [break_node])
error = assert_raises(errors.TypeCheckError,
lambda: check_loop_control(node, False))
assert_equal(break_node, error.node)
assert_equal("'break' outside loop", str(error))
def break_is_not_valid_in_function_in_while_loop_body():
break_node = nodes.break_()
func_node = nodes.func("f", nodes.args([]), [break_node], type=None)
node = nodes.while_(nodes.bool_literal(True), [func_node], [])
error = assert_raises(errors.TypeCheckError,
lambda: check_loop_control(node, False))
assert_equal(break_node, error.node)
assert_equal("'break' outside loop", str(error))
def potentially_bound_variable_becomes_definitely_bound_after_being_assigned_in_both_branches_of_if_else():
target_node = nodes.ref("x")
node = nodes.if_(
nodes.bool_literal(True),
[nodes.assign([target_node], nodes.none())],
[]
)
bindings = _updated_bindings(node)
assert not bindings.is_definitely_bound(target_node)
node = nodes.if_(
nodes.bool_literal(True),
[nodes.assign([target_node], nodes.none())],
[nodes.assign([target_node], nodes.none())]
)
bindings = _updated_bindings(node)
assert bindings.is_definitely_bound(target_node)
def children_of_while_loop_are_checked():
_assert_child_expression_is_checked(lambda generate:
nodes.while_(generate.unbound_ref(), [], [])
)
_assert_child_statement_is_checked(lambda generate:
nodes.while_(
nodes.bool_literal(True),
[generate.unbound_ref_statement()],
[]
)
)
_assert_child_statement_is_checked(lambda generate:
nodes.while_(
nodes.bool_literal(True),
[],
[generate.unbound_ref_statement()]
)
)
def variable_remains_definitely_bound_after_being_reassigned_in_one_branch_of_if_else():
target_node = nodes.ref("x")
node = nodes.if_(
nodes.bool_literal(True),
[nodes.assign([target_node], nodes.none())],
[]
)
bindings = _updated_bindings(node, is_definitely_bound={"x": True})
assert bindings.is_definitely_bound(target_node)
def first_argument_in_method_signature_can_be_strict_supertype_of_class():
node = nodes.class_("User", [
nodes.func(
name="is_person",
args=nodes.args([nodes.arg("self")]),
body=[nodes.ret(nodes.bool_literal(True))],
type=nodes.signature(
args=[nodes.signature_arg(nodes.ref("object"))],
returns=nodes.ref("bool")
),
)
])
class_type = _infer_class_type(node, ["is_person"])
assert_equal(types.func([], types.bool_type), class_type.attrs.type_of("is_person"))
def attributes_with_function_type_defined_in_class_definition_body_are_bound_to_class_type():
node = nodes.class_("User", [
nodes.func(
name="is_person",
args=nodes.args([nodes.arg("self")]),
body=[nodes.ret(nodes.bool_literal(True))],
type=nodes.signature(
args=[nodes.signature_arg(nodes.ref("Self"))],
returns=nodes.ref("bool")
),
),
])
class_type = _infer_class_type(node, ["is_person"])
assert_equal(types.func([], types.bool_type), class_type.attrs.type_of("is_person"))
def methods_must_have_at_least_one_argument():
func_node = nodes.func(
name="is_person",
args=nodes.args([]),
body=[nodes.ret(nodes.bool_literal(True))],
type=nodes.signature(
args=[],
returns=nodes.ref("bool")
)
)
node = nodes.class_("User", [func_node])
try:
_infer_class_type(node, ["is_person"])
assert False, "Expected error"
except errors.MethodHasNoArgumentsError as error:
assert_equal(func_node, error.node)
assert_equal("'is_person' method must have at least one argument", str(error))
def only_values_that_are_definitely_bound_are_exported():
module_node = nodes.module([
nodes.if_(
nodes.bool_literal(True),
[
nodes.assign(["x"], nodes.str_literal("one")),
nodes.assign(["y"], nodes.str_literal("two")),
],
[
nodes.assign(["y"], nodes.str_literal("three")),
]
)
])
module, type_lookup = _check(LocalModule(None, module_node))
assert_equal(None, module.attrs.get("x"))
assert_equal(types.str_type, module.attrs.type_of("y"))
def self_argument_in_method_signature_cannot_be_unrelated_type():
func_node = nodes.func(
name="is_person",
args=nodes.args([nodes.arg("self")]),
body=[nodes.ret(nodes.bool_literal(True))],
type=nodes.signature(
args=[nodes.signature_arg(nodes.ref("bool"))],
returns=nodes.ref("bool")
),
)
node = nodes.class_("User", [func_node])
try:
_infer_class_type(node, ["is_person"])
assert False, "Expected error"
except errors.UnexpectedReceiverTypeError as error:
assert_equal(func_node, error.node)
assert_equal(types.bool_type, error.receiver_type)
assert_equal("first argument of methods should have Self type but was 'bool'", str(error))
def test_function_without_explicit_return_on_all_paths_returns_none_at_end(self):
_assert_transform(
nodes.func(
name="f",
args=nodes.args([]),
body=[
nodes.if_(
nodes.ref("x"),
[nodes.ret(nodes.bool_literal(True))],
[]
),
],
type=None
),
cc.func("f", [], [
cc.if_(
cc.call(cc.builtin("bool"), [cc.ref("x")]),
[cc.ret(cc.true)],
),
cc.ret(cc.none),
]),
)
def break_is_valid_in_while_loop_body():
node = nodes.while_(nodes.bool_literal(True), [nodes.break_()])
check_loop_control(node, False)
def test_transform(self):
_assert_transform(nodes.bool_literal(True), cc.true)
_assert_transform(nodes.bool_literal(False), cc.false)
def bool_has_no_references():
_assert_no_references(nodes.bool_literal(True))
def while_loop_has_else_body_type_checked():
assert_statement_is_type_checked(
lambda bad_statement:
nodes.while_(nodes.bool_literal(True), [], [bad_statement])
)
def test_parse_booleans():
_assert_expression_parse(nodes.bool_literal(True), "True")
_assert_expression_parse(nodes.bool_literal(False), "False")
def declarations_in_both_body_and_else_body_of_while_loop_are_not_definitely_bound():
_assert_name_is_not_definitely_bound(lambda generate:
nodes.while_(nodes.bool_literal(True), [generate.assignment()], [generate.assignment()])
)
def attributes_defined_in_class_definition_body_are_present_on_meta_type():
node = nodes.class_("User", [
nodes.assign([nodes.ref("is_person")], nodes.bool_literal(True)),
])
meta_type = _infer_meta_type(node, ["is_person"])
assert_equal(types.bool_type, meta_type.attrs.type_of("is_person"))
def can_infer_type_of_boolean_literal():
assert_equal(types.bool_type, infer(nodes.bool_literal(True)))
def boolean_is_literal(self):
assert is_literal(nodes.bool_literal(True))
def declarations_in_both_if_else_branches_are_definitely_bound():
_assert_name_is_definitely_bound(lambda generate:
nodes.if_(nodes.bool_literal(True), [generate.assignment()], [generate.assignment()])
)
def assert_message_is_type_checked():
assert_expression_is_type_checked(
lambda bad_expr: nodes.assert_(nodes.bool_literal(False), bad_expr)
)
