def testMetaclass(self):
cls = abstract.InterpreterClass("X", [], {}, None, self._vm)
meta = abstract.InterpreterClass("M", [], {}, None, self._vm)
meta.official_name = "M"
cls.cls = meta.to_variable(self._vm.root_cfg_node)
pytd_cls = cls.to_pytd_def(self._vm.root_cfg_node, "X")
self.assertEqual(pytd_cls.metaclass, pytd.NamedType("M"))
def test_class_no_valself(self):
meta_members = {"x": self.vm.convert.none.to_variable(self.node)}
meta = abstract.InterpreterClass("M", [], meta_members, None, self.vm)
cls = abstract.InterpreterClass("X", [], {}, meta, self.vm)
_, attr_var = self.attribute_handler.get_attribute(self.node, cls, "x")
# Since `valself` was not passed to get_attribute, we do not look at the
# metaclass, so M.x is not returned.
self.assertIsNone(attr_var)
def test_class_with_class_valself(self):
meta_members = {"x": self.vm.convert.none.to_variable(self.node)}
meta = abstract.InterpreterClass("M", [], meta_members, None, self.vm)
cls = abstract.InterpreterClass("X", [], {}, meta, self.vm)
valself = cls.to_binding(self.node)
_, attr_var = self.attribute_handler.get_attribute(
self.node, cls, "x", valself)
# Since `valself` is X itself, we look at the metaclass and return M.x.
self.assertEqual(attr_var.data, [self.vm.convert.none])
def testInheritedMetaclass(self):
parent = abstract.InterpreterClass("X", [], {}, None, self._vm)
meta = abstract.InterpreterClass("M", [], {}, None, self._vm)
meta.official_name = "M"
parent.cls = meta.to_variable(self._vm.root_cfg_node)
child = abstract.InterpreterClass(
"Y", [parent.to_variable(self._vm.root_cfg_node)], {}, None, self._vm)
self.assertIs(child.cls, parent.cls)
pytd_cls = child.to_pytd_def(self._vm.root_cfg_node, "Y")
self.assertIs(pytd_cls.metaclass, None)
def test_metaclass_union(self):
cls = abstract.InterpreterClass("X", [], {}, None, self._vm)
meta1 = abstract.InterpreterClass("M1", [], {}, None, self._vm)
meta2 = abstract.InterpreterClass("M2", [], {}, None, self._vm)
meta1.official_name = "M1"
meta2.official_name = "M2"
cls.cls = abstract.Union([meta1, meta2], self._vm)
pytd_cls = cls.to_pytd_def(self._vm.root_cfg_node, "X")
self.assertEqual(pytd_cls.metaclass, pytd.UnionType(
(pytd.NamedType("M1"), pytd.NamedType("M2"))))
def test_class_with_instance_valself(self):
meta_members = {"x": self.vm.convert.none.to_variable(self.node)}
meta = abstract.InterpreterClass("M", [], meta_members, None, self.vm)
cls = abstract.InterpreterClass("X", [], {}, meta, self.vm)
valself = abstract.Instance(cls, self.vm).to_binding(self.node)
_, attr_var = self.attribute_handler.get_attribute(
self.node, cls, "x", valself)
# Since `valself` is an instance of X, we do not look at the metaclass, so
# M.x is not returned.
self.assertIsNone(attr_var)
def testTypeParameterEquality(self):
param1 = abstract.TypeParameter("S", self._vm)
param2 = abstract.TypeParameter("T", self._vm)
cls = abstract.InterpreterClass("S", [], {}, None, self._vm)
self.assertEqual(param1, param1)
self.assertNotEqual(param1, param2)
self.assertNotEqual(param1, cls)
def testUnionEquality(self):
union1 = abstract.Union((self._vm.convert.unsolvable, ), self._vm)
union2 = abstract.Union((self._vm.convert.none, ), self._vm)
cls = abstract.InterpreterClass("Union", [], {}, None, self._vm)
self.assertEqual(union1, union1)
self.assertNotEqual(union1, union2)
self.assertNotEqual(union1, cls)
def test_inherited_abstract_method(self):
sized_pytd = self._vm.loader.typing.Lookup("typing.Sized")
sized = self._vm.convert.constant_to_value(
sized_pytd, {}, self._vm.root_cfg_node)
cls = abstract.InterpreterClass(
"X", [sized.to_variable(self._vm.root_cfg_node)], {}, None, self._vm)
six.assertCountEqual(self, cls.abstract_methods, {"__len__"})
def test_overridden_abstract_method(self):
sized_pytd = self._vm.loader.typing.Lookup("typing.Sized")
sized = self._vm.convert.constant_to_value(
sized_pytd, {}, self._vm.root_cfg_node)
bases = [sized.to_variable(self._vm.root_cfg_node)]
members = {"__len__": self._vm.new_unsolvable(self._vm.root_cfg_node)}
cls = abstract.InterpreterClass("X", bases, members, None, self._vm)
self.assertFalse(cls.abstract_methods)
def test_getitem_with_instance_valself(self):
cls = abstract.InterpreterClass("X", [], {}, None, self.vm)
valself = abstract.Instance(cls, self.vm).to_binding(self.node)
_, attr_var = self.attribute_handler.get_attribute(
self.node, cls, "__getitem__", valself)
# Since we passed in `valself` for this lookup of __getitem__ on a class,
# it is treated as a normal lookup; X.__getitem__ does not exist.
self.assertIsNone(attr_var)
def test_getitem_no_valself(self):
cls = abstract.InterpreterClass("X", [], {}, None, self.vm)
_, attr_var = self.attribute_handler.get_attribute(
self.node, cls, "__getitem__")
attr, = attr_var.data
# Since we looked up __getitem__ on a class without passing in `valself`,
# the class is treated as an annotation.
self.assertIs(attr.func.__func__,
abstract.AnnotationClass.getitem_slot)
def testOverriddenAbstractMethodStillAbstract(self):
sized_pytd = self._vm.loader.typing.Lookup("typing.Sized")
sized = self._vm.convert.constant_to_value(sized_pytd, {},
self._vm.root_cfg_node)
bases = [sized.to_variable(self._vm.root_cfg_node)]
func = abstract.Function("__len__", self._vm)
func.is_abstract = True
members = {"__len__": func.to_variable(self._vm.root_cfg_node)}
cls = abstract.InterpreterClass("X", bases, members, None, self._vm)
self.assertListEqual(cls.abstract_methods, ["__len__"])
def testInterpreterClassOfficialName(self):
cls = abstract.InterpreterClass("X", [], {}, None, self._vm)
cls.update_official_name("Z")
self.assertEqual(cls.official_name, "Z")
cls.update_official_name("A") # takes effect because A < Z
self.assertEqual(cls.official_name, "A")
cls.update_official_name("Z") # no effect
self.assertEqual(cls.official_name, "A")
cls.update_official_name("X") # takes effect because X == cls.name
self.assertEqual(cls.official_name, "X")
cls.update_official_name("A") # no effect
self.assertEqual(cls.official_name, "X")
def test_union_set_attribute(self):
list_instance = abstract.Instance(self._vm.convert.list_type, self._vm)
cls = abstract.InterpreterClass("obj", [], {}, None, self._vm)
cls_instance = abstract.Instance(cls, self._vm)
union = abstract.Union([cls_instance, list_instance], self._vm)
node = self._vm.attribute_handler.set_attribute(
self._vm.root_cfg_node, union, "rumpelstiltskin",
self._vm.convert.none_type.to_variable(self._vm.root_cfg_node))
self.assertEqual(cls_instance.members["rumpelstiltskin"].data.pop(),
self._vm.convert.none_type)
self.assertIs(node, self._vm.root_cfg_node)
error, = self._vm.errorlog.unique_sorted_errors()
self.assertEqual(error.name, "not-writable")
def testInstantiateInterpreterClass(self):
cls = abstract.InterpreterClass("X", [], {}, None, self._vm)
# When there is no current frame, create a new instance every time.
v1 = abstract.get_atomic_value(cls.instantiate(self._node))
v2 = abstract.get_atomic_value(cls.instantiate(self._node))
self.assertIsNot(v1, v2)
# Create one instance per opcode.
fake_opcode = object()
self._vm.push_frame(frame_state.SimpleFrame(fake_opcode))
v3 = abstract.get_atomic_value(cls.instantiate(self._node))
v4 = abstract.get_atomic_value(cls.instantiate(self._node))
self.assertIsNot(v1, v3)
self.assertIsNot(v2, v3)
self.assertIs(v3, v4)
def test_abstract_method(self):
func = abstract.Function("f", self._vm).to_variable(self._vm.root_node)
func.data[0].is_abstract = True
cls = abstract.InterpreterClass("X", [], {"f": func}, None, self._vm)
six.assertCountEqual(self, cls.abstract_methods, {"f"})
def test_compatible_with(self):
cls = abstract.InterpreterClass("X", [], {}, None, self._vm)
self.assertIs(True, compare.compatible_with(cls, True))
self.assertIs(False, compare.compatible_with(cls, False))
def _make_class(self, name):
return abstract.InterpreterClass(name, [], {}, None, self.vm)
def test_compatible_with(self):
cls = abstract.InterpreterClass("X", [], {}, None, self._vm)
self.assertTruthy(cls)
def testAbstractMethod(self):
func = abstract.Function("f",
self._vm).to_variable(self._vm.root_cfg_node)
func.data[0].is_abstract = True
cls = abstract.InterpreterClass("X", [], {"f": func}, None, self._vm)
self.assertListEqual(cls.abstract_methods, ["f"])
