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 __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 testEmptyAgainstNothing(self):
var = self.vm.program.NewVariable()
right = abstract.Nothing(self.vm)
result = self.vm.matcher.match_var_against_type(
var, right, {}, self.vm.root_cfg_node, {})
self.assertEqual(result, {})
def testBasic(self): self.assertMatch(abstract.Empty(self.vm), abstract.Nothing(self.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)
