def test_is_instance(self):
def check(expected, left, right):
self.assertEquals(expected,
self._is_instance._is_instance(left, right))
obj_class = self._vm.convert.primitive_classes[object].bindings[0].data
# Unknown and Unsolvable are ambiguous.
check(None, abstract.Unknown(self._vm), obj_class)
check(None, abstract.Unsolvable(self._vm), obj_class)
# If the object's class has multiple bindings, result is ambiguous.
obj = abstract.SimpleAbstractValue("foo", self._vm)
check(None, obj, obj_class)
obj.set_class(self._node, self.new_var(self._str_class,
self._int_class))
check(None, obj, self._str_class)
# If the class_spec is not a class, result is ambiguous.
check(None, self._str, self._str)
# Result is True/False depending on if the class is in the object's mro.
check(True, self._str, obj_class)
check(True, self._str, self._str_class)
check(False, self._str, self._int_class)
def create_new_unknown(self, node, name, source=None, action=None):
"""Create a new variable containing unknown."""
if not self.vm.generate_unknowns:
# unsolvable instances are cheaper than unknown, so use those for --quick.
return abstract.Unsolvable(self.vm).to_variable(node, name)
unknown = self._create_new_unknown_value(action)
v = self.vm.program.NewVariable(name)
val = v.AddBinding(unknown,
source_set=[source] if source else [],
where=node)
unknown.owner = val
self.vm.trace_unknown(unknown.class_name, v)
return v
def __init__(self, vm):
super(Converter, self).__init__(vm)
self.vm.convert = self # to make constant_to_value calls below work
self.pytd_convert = output.Converter(vm)
self._convert_cache = {}
self._resolved_late_types = {} # performance cache
# Initialize primitive_classes to empty to allow constant_to_value to run.
self.primitive_classes = ()
# object_type is needed to initialize the primitive class values.
self.object_type = self.constant_to_value(object)
if self.vm.PY2:
version_specific = [compat.UnicodeType]
else:
version_specific = [compat.BytesType]
# Now fill primitive_classes with the real values using constant_to_value.
self.primitive_classes = {
v: self.constant_to_value(v)
for v in [
int, float, str, object, frozenset, compat.NoneType, complex,
bool, slice, types.CodeType, compat.EllipsisType,
compat.OldStyleClassType, super
] + version_specific
}
self.primitive_class_names = [
self._type_to_name(x) for x in self.primitive_classes
]
self.none = abstract.AbstractOrConcreteValue(
None, self.primitive_classes[compat.NoneType], self.vm)
self.true = abstract.AbstractOrConcreteValue(
True, self.primitive_classes[bool], self.vm)
self.false = abstract.AbstractOrConcreteValue(
False, self.primitive_classes[bool], self.vm)
self.ellipsis = abstract.AbstractOrConcreteValue(
Ellipsis, self.primitive_classes[compat.EllipsisType], self.vm)
self.primitive_class_instances = {}
for name, cls in self.primitive_classes.items():
if name == compat.NoneType:
# This is possible because all None instances are the same.
# Without it pytype could not reason that "x is None" is always true, if
# x is indeed None.
instance = self.none
elif name == compat.EllipsisType:
instance = self.ellipsis
else:
instance = abstract.Instance(cls, self.vm)
self.primitive_class_instances[name] = instance
self._convert_cache[(abstract.Instance, cls.pytd_cls)] = instance
self.none_type = self.primitive_classes[compat.NoneType]
self.oldstyleclass_type = self.primitive_classes[
compat.OldStyleClassType]
self.super_type = self.primitive_classes[super]
self.str_type = self.primitive_classes[str]
self.int_type = self.primitive_classes[int]
self.unsolvable = abstract.Unsolvable(self.vm)
self.empty = abstract.Empty(self.vm)
self.no_return = typing_overlay.NoReturn(self.vm)
self.list_type = self.constant_to_value(list)
self.set_type = self.constant_to_value(set)
self.dict_type = self.constant_to_value(dict)
self.type_type = self.constant_to_value(type)
self.module_type = self.constant_to_value(types.ModuleType)
self.function_type = self.constant_to_value(types.FunctionType)
self.tuple_type = self.constant_to_value(tuple)
self.generator_type = self.constant_to_value(types.GeneratorType)
self.iterator_type = self.constant_to_value(compat.IteratorType)
self.bool_values = {
True: self.true,
False: self.false,
None: self.primitive_class_instances[bool],
}
if self.vm.PY2:
self.unicode_type = self.primitive_classes[compat.UnicodeType]
self.bytes_type = self.str_type
self.next_attr = "next"
else:
self.unicode_type = self.str_type
self.bytes_type = self.primitive_classes[compat.BytesType]
self.next_attr = "__next__"
def __init__(self, vm):
self.vm = vm
self.vm.convert = self # to make constant_to_value calls below work
self.pytd_convert = output.Converter()
self._convert_cache = {}
self._resolved_late_types = {} # performance cache
# Initialize primitive_classes to empty to allow constant_to_value to run.
self.primitive_classes = ()
# object_type is needed to initialize the primitive class values.
self.object_type = self.constant_to_value(object)
# Now fill primitive_classes with the real values using constant_to_value.
self.primitive_classes = {
v: self.constant_to_value(v)
for v in [
int, float, str, unicode, object, types.NoneType, complex,
bool, slice, types.CodeType, types.EllipsisType,
types.ClassType, super
]
}
self.primitive_class_names = [
x.__module__ + "." + x.__name__ for x in self.primitive_classes
]
self.none = abstract.AbstractOrConcreteValue(
None, self.primitive_classes[types.NoneType], self.vm)
self.true = abstract.AbstractOrConcreteValue(
True, self.primitive_classes[bool], self.vm)
self.false = abstract.AbstractOrConcreteValue(
False, self.primitive_classes[bool], self.vm)
self.ellipsis = abstract.AbstractOrConcreteValue(
Ellipsis, self.primitive_classes[types.EllipsisType], self.vm)
self.primitive_class_instances = {}
for name, cls in self.primitive_classes.items():
if name == types.NoneType:
# This is possible because all None instances are the same.
# Without it pytype could not reason that "x is None" is always true, if
# x is indeed None.
instance = self.none
elif name == types.EllipsisType:
instance = self.ellipsis
else:
instance = abstract.Instance(cls, self.vm)
self.primitive_class_instances[name] = instance
self._convert_cache[(abstract.Instance, cls.pytd_cls)] = instance
self.none_type = self.primitive_classes[types.NoneType]
self.oldstyleclass_type = self.primitive_classes[types.ClassType]
self.super_type = self.primitive_classes[super]
self.str_type = self.primitive_classes[str]
self.int_type = self.primitive_classes[int]
self.nothing = abstract.Nothing(self.vm)
self.unsolvable = abstract.Unsolvable(self.vm)
self.empty = abstract.Empty(self.vm)
self.list_type = self.constant_to_value(list)
self.set_type = self.constant_to_value(set)
self.dict_type = self.constant_to_value(dict)
self.type_type = self.constant_to_value(type)
self.module_type = self.constant_to_value(types.ModuleType)
self.function_type = self.constant_to_value(types.FunctionType)
self.tuple_type = self.constant_to_value(tuple)
self.generator_type = self.constant_to_value(types.GeneratorType)
# TODO(dbaum): There isn't a types.IteratorType. This can probably be
# based on typing.Iterator, but that will also require changes to
# convert.py since that assumes all types can be looked up in
# __builtin__.
self.iterator_type = self.constant_to_value(types.ObjectType)
self.bool_values = {
True: self.true,
False: self.false,
None: self.primitive_class_instances[bool],
}
def call(self, node, _, args):
self.vm.errorlog.not_callable(self.vm.frames, self)
return node, abstract.Unsolvable(self.vm).to_variable(node)
def __init__(self, vm):
self.vm = vm
self.vm.convert = self # to make convert_constant calls below work
self._convert_cache = {}
# Initialize primitive_classes to empty to allow convert_constant to run
self.primitive_classes = ()
# Now fill primitive_classes with the real values using convert_constant
self.primitive_classes = {v: self.convert_constant(v.__name__, v)
for v in [int, long, float, str, unicode, object,
types.NoneType, complex, bool, slice,
types.CodeType, types.EllipsisType,
types.ClassType, super]}
self.none = abstract.AbstractOrConcreteValue(
None, self.primitive_classes[types.NoneType], self.vm,
self.vm.root_cfg_node)
self.true = abstract.AbstractOrConcreteValue(
True, self.primitive_classes[bool], self.vm, self.vm.root_cfg_node)
self.false = abstract.AbstractOrConcreteValue(
False, self.primitive_classes[bool], self.vm, self.vm.root_cfg_node)
self.ellipsis = abstract.AbstractOrConcreteValue(
Ellipsis, self.primitive_classes[types.EllipsisType], self.vm,
self.vm.root_cfg_node)
self.primitive_class_instances = {}
for name, clsvar in self.primitive_classes.items():
instance = abstract.Instance(clsvar, self.vm, self.vm.root_cfg_node)
self.primitive_class_instances[name] = instance
clsval, = clsvar.bindings
self._convert_cache[(abstract.Instance, clsval.data.pytd_cls)] = instance
self.primitive_class_instances[types.NoneType] = self.none
self.none_type = self.primitive_classes[types.NoneType]
self.object_type = self.primitive_classes[object]
self.oldstyleclass_type = self.primitive_classes[types.ClassType]
self.super_type = self.primitive_classes[super]
self.str_type = self.primitive_classes[str]
self.int_type = self.primitive_classes[int]
self.nothing = abstract.Nothing(self.vm)
self.unsolvable = abstract.Unsolvable(self.vm)
self.tuple_type = self.convert_constant("tuple", tuple)
self.list_type = self.convert_constant("list", list)
self.set_type = self.convert_constant("set", set)
self.dict_type = self.convert_constant("dict", dict)
self.type_type = self.convert_constant("type", type)
self.module_type = self.convert_constant("module", types.ModuleType)
self.function_type = self.convert_constant(
"function", types.FunctionType)
self.generator_type = self.convert_constant(
"generator", types.GeneratorType)
# TODO(dbaum): There isn't a types.IteratorType. This can probably be
# based on typing.Iterator, but that will also require changes to
# convert.py since that assumes all types can be looked up in
# __builtin__.
self.iterator_type = self.convert_constant(
"iterator", types.ObjectType)
self.bool_values = {
True: self.true,
False: self.false,
None: self.primitive_class_instances[bool],
}
self.undefined = self.vm.program.NewVariable("undefined")
def build_any(name, vm):
del name
return abstract.Unsolvable(vm)
def build_namedtuple(name, vm):
del name
return abstract.Unsolvable(vm)
def build_namedtuple(name, vm):
vm.errorlog.not_supported_yet(vm.frames, "typing." + name)
return abstract.Unsolvable(vm)
def __init__(self, vm):
self.vm = vm
self.vm.convert = self # to make constant_to_var calls below work
self.pytd_convert = output.Converter()
self._convert_cache = {}
# Initialize primitive_classes to empty to allow constant_to_var to run
self.primitive_classes = ()
# Now fill primitive_classes with the real values using constant_to_var
self.primitive_classes = {
v: self.constant_to_var(v.__name__, v)
for v in [
int, float, str, unicode, object, types.NoneType, complex,
bool, slice, types.CodeType, types.EllipsisType,
types.ClassType, super
]
}
self.none = abstract.AbstractOrConcreteValue(
None, self.primitive_classes[types.NoneType], self.vm,
self.vm.root_cfg_node)
self.true = abstract.AbstractOrConcreteValue(
True, self.primitive_classes[bool], self.vm, self.vm.root_cfg_node)
self.false = abstract.AbstractOrConcreteValue(
False, self.primitive_classes[bool], self.vm,
self.vm.root_cfg_node)
self.ellipsis = abstract.AbstractOrConcreteValue(
Ellipsis, self.primitive_classes[types.EllipsisType], self.vm,
self.vm.root_cfg_node)
self.primitive_class_instances = {}
for name, clsvar in self.primitive_classes.items():
if name == types.NoneType:
# This is possible because all None instances are the same.
# Without it pytype could not reason that "x is None" is always true, if
# x is indeed None.
instance = self.none
elif name == types.EllipsisType:
instance = self.ellipsis
else:
instance = abstract.Instance(clsvar, self.vm,
self.vm.root_cfg_node)
self.primitive_class_instances[name] = instance
clsval, = clsvar.bindings
self._convert_cache[(abstract.Instance,
clsval.data.pytd_cls)] = instance
self.none_type = self.primitive_classes[types.NoneType]
self.object_type = self.primitive_classes[object]
self.oldstyleclass_type = self.primitive_classes[types.ClassType]
self.super_type = self.primitive_classes[super]
self.str_type = self.primitive_classes[str]
self.int_type = self.primitive_classes[int]
self.nothing = abstract.Nothing(self.vm)
self.unsolvable = abstract.Unsolvable(self.vm)
self.empty = abstract.Empty(self.vm)
self.tuple_type = self.constant_to_var("tuple", tuple)
self.list_type = self.constant_to_var("list", list)
self.set_type = self.constant_to_var("set", set)
self.frozenset_type = self.constant_to_var("frozenset", frozenset)
self.dict_type = self.constant_to_var("dict", dict)
self.type_type = self.constant_to_var("type", type)
self.module_type = self.constant_to_var("module", types.ModuleType)
self.function_type = self.constant_to_var("function",
types.FunctionType)
self.generator_type = self.constant_to_var("generator",
types.GeneratorType)
# TODO(dbaum): There isn't a types.IteratorType. This can probably be
# based on typing.Iterator, but that will also require changes to
# convert.py since that assumes all types can be looked up in
# __builtin__.
self.iterator_type = self.constant_to_var("iterator", types.ObjectType)
self.bool_values = {
True: self.true,
False: self.false,
None: self.primitive_class_instances[bool],
}
self.empty_type = self.empty.to_variable(self.vm.root_cfg_node)
object_val, = self.object_type.data
object_val.load_lazy_attribute("__new__")
self.object_new, = object_val.members["__new__"].data
self.typing_overlay = typing.TypingOverlay(self.vm,
self.vm.root_cfg_node)
def test_singleton(self): self.assertIs(abstract.Unsolvable(self._vm), abstract.Unsolvable(self._vm))
