def call(self, node, _, args): posargs = args.posargs if isinstance(args.namedargs, dict): namedargs = args.namedargs else: namedargs = self.vm.convert.value_to_constant(args.namedargs, dict) if namedargs and self.vm.python_version < (3, 6): errmsg = "Keyword syntax for NamedTuple is only supported in Python 3.6+" self.vm.errorlog.invalid_namedtuple_arg(self.vm.frames, err_msg=errmsg) if namedargs and len(posargs) == 1: namedargs = [ abstract.Tuple((self.vm.convert.build_string(node, k), v), self.vm).to_variable(node) for k, v in namedargs.items() ] namedargs = abstract.List(namedargs, self.vm).to_variable(node) posargs += (namedargs, ) args = function.Args(posargs) elif namedargs: errmsg = ("Either list of fields or keywords can be provided to " "NamedTuple, not both") self.vm.errorlog.invalid_namedtuple_arg(self.vm.frames, err_msg=errmsg) return self.namedtuple.call(node, None, args)
def testToTypeWithViewAndEmptyParam(self): instance = abstract.List([], self._vm) view = {instance.cls: instance.cls.bindings[0]} pytd_type = instance.to_type(self._vm.root_cfg_node, seen=None, view=view) self.assertEqual("__builtin__.list", pytd_type.base_type.name) self.assertSequenceEqual((pytd.NothingType(), ), pytd_type.parameters)
def test_compatible_with_list(self): i = abstract.List([], self._vm) # Empty list is not compatible with True. self.assertFalsy(i) # Once a type parameter is set, list is compatible with True and False. i.merge_instance_type_parameter( self._node, abstract_utils.T, self._vm.convert.object_type.to_variable(self._vm.root_cfg_node)) self.assertAmbiguous(i)
def test_compatible_with_list(self): i = abstract.List([], self._vm) # Empty list is not compatible with True. self.assertIs(False, i.compatible_with(True)) self.assertIs(True, i.compatible_with(False)) # Once a type parameter is set, list is compatible with True and False. i.merge_type_parameter( self._node, abstract.T, self._vm.convert.object_type.to_variable(self._vm.root_cfg_node)) self.assertIs(True, i.compatible_with(True)) self.assertIs(True, i.compatible_with(False))
def test_to_type_with_view1(self): # to_type(<instance of List[int or unsolvable]>, view={T: int}) instance = abstract.List([], self._vm) instance.merge_instance_type_parameter( self._vm.root_cfg_node, abstract_utils.T, self._vm.program.NewVariable( [self._vm.convert.unsolvable], [], self._vm.root_cfg_node)) param_binding = instance.get_instance_type_parameter( abstract_utils.T).AddBinding( self._vm.convert.primitive_class_instances[int], [], self._vm.root_cfg_node) view = { instance.get_instance_type_parameter(abstract_utils.T): param_binding} pytd_type = instance.to_type(self._vm.root_cfg_node, seen=None, view=view) self.assertEqual("__builtin__.list", pytd_type.base_type.name) self.assertSetEqual({"__builtin__.int"}, {t.name for t in pytd_type.parameters})
def testToTypeWithView1(self): # to_type(<instance of List[int or unsolvable]>, view={T: int}) instance = abstract.List([], self._vm) instance.merge_type_parameter( self._vm.root_cfg_node, abstract.T, self._vm.program.NewVariable( [self._vm.convert.unsolvable], [], self._vm.root_cfg_node)) param_binding = instance.type_parameters[abstract.T].AddBinding( self._vm.convert.primitive_class_instances[int], [], self._vm.root_cfg_node) view = {instance.cls: instance.cls.bindings[0], instance.type_parameters[abstract.T]: param_binding, param_binding.data.cls: param_binding.data.cls.bindings[0]} pytd_type = instance.to_type(self._vm.root_cfg_node, seen=None, view=view) self.assertEqual("__builtin__.list", pytd_type.base_type.name) self.assertSetEqual({"__builtin__.int"}, {t.name for t in pytd_type.parameters})
def build_list(self, node, content): """Create a VM list from the given sequence.""" # TODO(rechen): set T to empty if there is nothing in content content = [var.AssignToNewVariable(node) for var in content] return abstract.List(content, self.vm).to_variable(node)
def test_to_type_with_view_and_empty_param(self): instance = abstract.List([], self._vm) pytd_type = instance.to_type(self._vm.root_cfg_node, seen=None, view={}) self.assertEqual("__builtin__.list", pytd_type.base_type.name) self.assertSequenceEqual((pytd.NothingType(),), pytd_type.parameters)
def build_list(self, node, content): """Create a VM list from the given sequence.""" # TODO(rechen): set T to empty if there is nothing in content content = list(content) # content might be a generator return abstract.List(content, self.vm).to_variable(node)