def children_of_for_loop_are_checked():
_assert_child_expression_is_checked(lambda generate:
nodes.for_(
nodes.attr(generate.unbound_ref(), "blah"),
nodes.list_literal([]),
[],
[]
)
)
_assert_child_expression_is_checked(lambda generate:
nodes.for_(
generate.target(),
generate.unbound_ref(),
[],
[]
),
)
_assert_child_statement_is_checked(lambda generate:
nodes.for_(
generate.target(),
nodes.list_literal([]),
[generate.unbound_ref_statement()],
[]
),
)
_assert_child_statement_is_checked(lambda generate:
nodes.for_(
generate.target(),
nodes.list_literal([]),
[],
[generate.unbound_ref_statement()],
),
)
def error_is_raised_if_all_is_redeclared():
try:
all_node = nodes.assign(["__all__"], nodes.list_literal([]))
second_all_node = nodes.assign(["__all__"], nodes.list_literal([]))
_exported_names(nodes.module([all_node, second_all_node]))
assert False, "Expected error"
except errors.AllAssignmentError as error:
assert_equal(second_all_node, error.node)
assert_equal("__all__ cannot be redeclared", str(error))
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 list_comprehension_target_is_definitely_bound():
node = nodes.list_comprehension(
nodes.ref("x"),
nodes.ref("x"),
nodes.list_literal([]),
)
_updated_bindings(node)
def error_is_raised_if_all_does_not_contain_only_string_literals():
try:
all_node = nodes.assign(["__all__"], nodes.list_literal([nodes.none()]))
_exported_names(nodes.module([all_node]))
assert False, "Expected error"
except errors.AllAssignmentError as error:
assert_equal(all_node, error.node)
assert_equal("__all__ must be a list of string literals", str(error))
def declarations_in_both_body_and_else_body_of_for_loop_are_not_definitely_bound():
_assert_name_is_not_definitely_bound(lambda generate:
nodes.for_(
generate.target(),
nodes.list_literal([]),
[generate.assignment()],
[generate.assignment()]
),
)
def when_target_has_explicit_type_that_type_is_used_as_type_hint():
node = nodes.assign(
[nodes.ref("x")],
nodes.list_literal([nodes.str_literal("Hello")]),
type=nodes.type_apply(nodes.ref("list"), [nodes.ref("object")])
)
context = update_context(node, type_bindings={
"list": types.meta_type(types.list_type),
"object": types.meta_type(types.object_type),
})
assert_equal(types.list_type(types.object_type), context.lookup_name("x"))
def module_exports_are_specified_using_all():
module_node = nodes.module([
nodes.assign(["__all__"], nodes.list_literal([nodes.str_literal("x"), nodes.str_literal("z")])),
nodes.assign(["x"], nodes.str_literal("one")),
nodes.assign(["y"], nodes.str_literal("two")),
nodes.assign(["z"], nodes.int_literal(3)),
])
module, type_lookup = _check(LocalModule(None, module_node))
assert_equal(types.str_type, module.attrs.type_of("x"))
assert_equal(None, module.attrs.get("y"))
assert_equal(types.int_type, module.attrs.type_of("z"))
def children_of_list_comprehension_are_checked():
_assert_child_expression_is_checked(lambda generate:
nodes.list_comprehension(
generate.unbound_ref(),
generate.bound_ref("x", types.int_type),
nodes.list_literal([]),
)
)
_assert_child_expression_is_checked(lambda generate:
nodes.list_comprehension(
nodes.none(),
nodes.attr(generate.unbound_ref(), "x"),
nodes.list_literal([]),
)
)
_assert_child_expression_is_checked(lambda generate:
nodes.list_comprehension(
nodes.none(),
generate.bound_ref("x", types.int_type),
generate.unbound_ref(),
)
)
def for_loop_target_is_declared():
node = nodes.for_(nodes.ref("target"), nodes.list_literal([]), [], [])
declarations = find_declarations(node)
assert_equal("target", declarations.declaration("target").name)
assert isinstance(declarations.declaration("target"), name_declaration.VariableDeclarationNode)
def empty_list_can_be_typed_using_type_hint():
assert_equal(
types.list_type(types.int_type),
infer(nodes.list_literal([]), hint=types.list_type(types.int_type))
)
def empty_list_type_hint_is_ignored_if_type_hint_is_not_list():
assert_equal(
types.list_type(types.bottom_type),
infer(nodes.list_literal([]), hint=types.int_type)
)
def test_assignment_can_have_explicit_type():
expected = nodes.assign(
["x"], nodes.list_literal([]),
type=nodes.type_apply(nodes.ref("list"), [nodes.ref("str")])
)
_assert_statement_parse(expected, "#:: list[str]\nx = []")
def test_parse_list_literal():
_assert_expression_parse(nodes.list_literal([nodes.str_literal("hello"), nodes.int_literal(4)]), "['hello', 4]")
def non_empty_list_can_be_typed_using_type_hint():
assert_equal(
types.list_type(types.object_type),
infer(nodes.list_literal([nodes.int_literal(1)]), hint=types.list_type(types.object_type))
)
def list_type_hint_is_ignored_if_not_super_type_of_elements():
assert_equal(
types.list_type(types.int_type),
infer(nodes.list_literal([nodes.int_literal(1)]), hint=types.list_type(types.none_type))
)
def for_loop_target_is_defined_but_not_definitely_bound():
_assert_name_is_not_definitely_bound(lambda generate:
nodes.for_(generate.target(), nodes.list_literal([]), [], [])
)
def test_transform(self):
_assert_transform(
nodes.list_literal([nodes.none()]),
cc.list_literal([cc.none])
)
def empty_list_has_elements_of_type_bottom():
assert_equal(types.list_type(types.bottom_type), infer(nodes.list_literal([])))
def list_expression_has_names_in_elements_resolved():
_assert_children_resolved(
lambda ref: nodes.list_literal([ref]),
)
def list_containing_literal_is_literal(self):
assert is_literal(nodes.list_literal([nodes.none()]))
def list_containing_reference_is_not_literal(self):
assert not is_literal(nodes.list_literal([nodes.ref("x")]))
def empty_list_is_literal(self):
assert is_literal(nodes.list_literal([]))
def when_target_already_has_type_that_type_is_used_as_type_hint():
node = nodes.assign([nodes.ref("x")], nodes.list_literal([nodes.str_literal("Hello")]))
type_bindings = {"x": types.list_type(types.object_type)}
context = update_context(node, type_bindings=type_bindings)
assert_equal(types.list_type(types.object_type), context.lookup_name("x"))
def formal_type_of_argument_is_used_as_type_hint_for_actual_argument():
type_bindings = {"f": types.func([types.list_type(types.str_type)], types.int_type)}
node = nodes.call(nodes.ref("f"), [nodes.list_literal([])])
assert_equal(types.int_type, infer(node, type_bindings=type_bindings))
def can_infer_type_of_list_of_ints():
assert_equal(types.list_type(types.int_type), infer(nodes.list_literal([nodes.int_literal(1), nodes.int_literal(42)])))
