def test_out_both_if_nested_else(self): self.context.set_type_of(self.localization, "var1", long) self.context.set_type_of(self.localization, "var2", long) self.context = self.context.open_ssa_context("if") self.context.set_type_of(self.localization, "var1", int) self.context.set_type_of(self.localization, "var2", float) self.context.open_ssa_branch("else") # else self.context.set_type_of(self.localization, "var1", str) self.context.set_type_of(self.localization, "var2", str) self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context.set_type_of(self.localization, "var1", complex) self.context.set_type_of(self.localization, "var2", complex) self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() compare_types(self.context.get_type_of(self.localization, "var1"), [int, str, complex]) compare_types(self.context.get_type_of(self.localization, "var2"), [float, str, complex])
def test_out_and_nested_nested_else_some_branches(self): self.context.set_type_of(self.localization, "var1", int) self.context.set_type_of(self.localization, "var2", float) self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context.set_type_of(self.localization, "var1", complex) self.context.set_type_of(self.localization, "var2", complex) self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context.set_type_of(self.localization, "var1", list) self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() compare_types(self.context.get_type_of(self.localization, "var1"), [int, complex, list]) compare_types(self.context.get_type_of(self.localization, "var2"), [float, complex])
def test_context_store(self): self.context.set_type_of(self.localization, "var1", int) self.context.set_type_of(self.localization, "var2", float) self.context.set_type_of(self.localization, "var3", str) compare_types(self.context.get_type_of(self.localization, "var1"), int) compare_types(self.context.get_type_of(self.localization, "var2"), float) compare_types(self.context.get_type_of(self.localization, "var3"), str)
def test_both_if_nested_nested_else_some_branches(self): temp1 = self.context.get_type_of(self.localization, "var1") self.context = self.context.open_ssa_context("if") self.context.set_type_of_member(self.localization, temp1, "instance_attribute", int) self.context.set_type_of_member(self.localization, temp1, "instance_attribute2", float) self.context.open_ssa_branch("else") # else self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context.set_type_of_member(self.localization, temp1, "instance_attribute", complex) self.context.set_type_of_member(self.localization, temp1, "instance_attribute2", complex) self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context.set_type_of_member(self.localization, temp1, "instance_attribute", list) self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() compare_types(self.context.get_type_of_member(self.localization, temp1, "instance_attribute"), [int, complex, list, UndefinedType]) compare_types(self.context.get_type_of_member(self.localization, temp1, "instance_attribute2"), [float, complex, UndefinedType])
def test_only_nested_nested_else(self): self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context.set_type_of(self.localization, "var1", str) self.context.set_type_of(self.localization, "var2", str) self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context.set_type_of(self.localization, "var1", complex) self.context.set_type_of(self.localization, "var2", complex) self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context.set_type_of(self.localization, "var1", list) self.context.set_type_of(self.localization, "var2", list) self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() compare_types(self.context.get_type_of(self.localization, "var1"), [UndefinedType, str, complex, list]) compare_types(self.context.get_type_of(self.localization, "var2"), [UndefinedType, str, complex, list])
def test_union_invoke_return_types(self): class Foo: def method(self, localization): return True def method_2(self, localization): return str() class Foo2: def method(self, localization): return False def method_2(self, localization): return int() # Access a member that can be provided only by some of the types in the union union = UnionType.add(Foo(), Foo2()) method = self.type_store.get_type_of_member(self.loc, union, "method_2") res = invoke(self.loc, method) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0) compare_types(res, [str(), int()])
def test_out_both_if_maxdepth_nested_else(self): temp1 = self.context.get_type_of(self.localization, "var1") self.context.set_type_of_member(self.localization, temp1, "class_attribute", long) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", long) self.context = self.context.open_ssa_context("if") self.context.set_type_of_member(self.localization, temp1, "class_attribute", int) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", float) self.context.open_ssa_branch("else") # else self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context = self.context.open_ssa_context("if") self.context.open_ssa_branch("else") # else self.context.set_type_of_member(self.localization, temp1, "class_attribute", list) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", complex) self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute"), [int, list, long]) compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute2"), [float, complex, long])
def test_out_and_nested_nested_if_some_branches(self): temp1 = self.context.get_type_of(self.localization, "var1") self.context.set_type_of_member(self.localization, temp1, "class_attribute", int) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", float) self.context = self.context.open_ssa_context("if") self.context = self.context.open_ssa_context("if") self.context.set_type_of_member(self.localization, temp1, "class_attribute", complex) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", complex) self.context = self.context.open_ssa_context("if") self.context.set_type_of_member(self.localization, temp1, "class_attribute", list) self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute"), [int, complex, list]) compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute2"), [float, complex])
def test_nested_both_if_else(self): temp1 = self.context.get_type_of(self.localization, "var1") self.context = self.context.open_ssa_context("if") self.context.set_type_of_member(self.localization, temp1, "class_attribute", int) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", float) # Either if or else will be executed. Therefore the type of the variables will be overwritten no matter what self.context = self.context.open_ssa_context("if") self.context.set_type_of_member(self.localization, temp1, "class_attribute", list) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", list) self.context.open_ssa_branch("else") # else self.context.set_type_of_member(self.localization, temp1, "class_attribute", dict) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", dict) self.context = self.context.join_ssa_context() self.context.open_ssa_branch("else") # else self.context.set_type_of_member(self.localization, temp1, "class_attribute", str) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", str) self.context = self.context.join_ssa_context() compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute"), [str, list, dict]) compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute2"), [str, list, dict])
def test_out_nested_both_if_both_else(self): temp1 = self.context.get_type_of(self.localization, "var1") self.context.set_type_of_member(self.localization, temp1, "class_attribute", long) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", long) self.context = self.context.open_ssa_context("if") self.context.set_type_of_member(self.localization, temp1, "class_attribute", int) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", float) self.context = self.context.open_ssa_context("if") self.context.set_type_of_member(self.localization, temp1, "class_attribute", list) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", list) self.context.open_ssa_branch("else") # else self.context.set_type_of_member(self.localization, temp1, "class_attribute", dict) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", dict) self.context = self.context.join_ssa_context() self.context.open_ssa_branch("else") # else self.context.set_type_of_member(self.localization, temp1, "class_attribute", str) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", str) self.context = self.context.open_ssa_context("if") self.context.set_type_of_member(self.localization, temp1, "class_attribute", set) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", set) self.context.open_ssa_branch("else") # else self.context.set_type_of_member(self.localization, temp1, "class_attribute", bytearray) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", bytearray) self.context = self.context.join_ssa_context() self.context = self.context.join_ssa_context() compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute"), [list, dict, set, bytearray]) compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute2"), [list, dict, set, bytearray])
def test_context_store(self): temp1 = self.context.get_type_of(self.localization, "var1") self.context.set_type_of_member(self.localization, temp1, "class_attribute", int) self.context.set_type_of_member(self.localization, temp1, "class_attribute2", float) self.context.set_type_of_member(self.localization, temp1, "class_attribute3", str) compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute"), int) compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute2"), float) compare_types(self.context.get_type_of_member(self.localization, temp1, "class_attribute3"), str)
def test_create_union_type_with_mixed_types(self): int_var = int def fun(): pass class Foo: def method(self): pass def method_2(self): pass class_var = Foo method_var = Foo.method instance_var = Foo() import math module_var = math union = UnionType.create_from_type_list( [int_var, fun, class_var, method_var, instance_var, module_var]) compare_types( union, [int_var, fun, class_var, method_var, instance_var, module_var]) clone = UnionType.create_from_type_list( [int_var, fun, class_var, method_var, instance_var, module_var]) compare_types(union, clone) method2_var = Foo.method_2 UnionType.add(clone, types) UnionType.add(clone, method2_var) compare_types( union, [int_var, fun, class_var, method_var, instance_var, module_var]) compare_types(clone, [ int_var, fun, class_var, method_var, instance_var, module_var, method2_var, types ])
def test_wrong_call_builtin_module_class(self): type_ = self.context.get_type_of(self.localization, "list") compare_types(type_, list) # Wrong type ret = invoke(self.localization, type_, int()) compare_types(type(ret), StypyTypeError) # Wrong number of parameters ret = invoke(self.localization, type_, str(), int()) compare_types(type(ret), StypyTypeError)
def test_wrong_call_builtin_module_function_simple_types(self): func = self.context.get_type_of(self.localization, "abs") compare_types(type(func), types.BuiltinFunctionType) # Wrong param type ret = invoke(self.localization, func, [list()]) compare_types(type(ret), StypyTypeError) # Wrong param number ret = invoke(self.localization, func, [int(), int()]) compare_types(type(ret), StypyTypeError)
def test_create_union_type_with_vars(self): union = UnionType.add(int, str) compare_types(union, [int, str]) union2 = UnionType(union, list) compare_types(union, [int, str]) compare_types(union2, [int, str, list]) self.assertFalse(union == union2) clone = UnionType.add(int, str) self.assertTrue(union == clone)
def test_local_variable_turned_global_nested_context(self): self.type_store.declare_global(self.loc, "global_var") self.type_store.set_type_of(self.loc, "global_var", int) assert len(Advice.get_advice_msgs()) == 1 self.type_store = self.type_store.open_function_context("nested_func") num_warnings_before = len(TypeWarning.get_warning_msgs()) compare_types(self.type_store.get_type_of(Localization(__file__, 1, 1), "global_var"), types.IntType) num_warnings_after = len(TypeWarning.get_warning_msgs()) assert num_warnings_after == num_warnings_before + 1 self.type_store.declare_global(Localization(__file__, 2, 2), "global_var") assert len(Advice.get_advice_msgs()) == 2 self.type_store.declare_global(Localization(__file__, 3, 3), "non_existing") assert len(Advice.get_advice_msgs()) == 3 assert_if_not_error(self.type_store.get_type_of(self.loc, "non_existing")) self.type_store = self.type_store.open_function_context("other_func") self.type_store.set_type_of(Localization(__file__, 4, 4), "foo", int) self.type_store.declare_global(Localization(__file__, 5, 5), "foo") assert len(Advice.get_advice_msgs()) == 4 self.type_store.declare_global(Localization(__file__, 6, 6), "foo_func") self.type_store.set_type_of(Localization(__file__, 6, 6), "foo_func", types.FunctionType) assert len(Advice.get_advice_msgs()) == 5 self.type_store = self.type_store.close_function_context() compare_types(self.type_store.get_type_of(Localization(__file__, 1, 1), "foo"), types.IntType) self.type_store.set_type_of(Localization(__file__, 1, 1), "foo", types.FloatType) assert len(StypyTypeError.get_error_msgs()) == 2 self.type_store = self.type_store.close_function_context() compare_types(self.type_store.get_type_of(self.loc, "foo"), types.IntType) compare_types(self.type_store.get_type_of(self.loc, "foo_func"), types.FunctionType)
def test_wrong_call_builtin_module_class_method(self): type_ = self.context.get_type_of(self.localization, "list") compare_types(type_, list) method = self.context.get_type_of_member(self.localization, type_, "__getitem__") ret = invoke(self.localization, method, [list()]) compare_types(type(ret), StypyTypeError) method = self.context.get_type_of_member(self.localization, type_, "__getitem__") ret = invoke(self.localization, method, [int(), int()]) compare_types(type(ret), StypyTypeError)
def test_existing_global_var_usage(self): self.type_store.set_type_of(self.loc, "global_var", int) self.type_store.set_type_of(self.loc, "global_func", types.FunctionType) self.type_store = self.type_store.open_function_context("nested_func") self.type_store.declare_global(self.loc, "global_var") self.type_store.declare_global(self.loc, "global_func") num_warnings_before = len(TypeWarning.get_warning_msgs()) compare_types(self.type_store.get_type_of(self.loc, "global_var"), types.IntType) compare_types(self.type_store.get_type_of(self.loc, "global_func"), types.FunctionType) num_warnings_after = len(TypeWarning.get_warning_msgs()) # TypeWarning.print_warning_msgs() assert num_warnings_after == num_warnings_before res = self.type_store.set_type_of(self.loc, "global_var", str) res = self.type_store.set_type_of(self.loc, "global_func", types.NoneType) assert res is None self.type_store = self.type_store.close_function_context() compare_types(self.type_store.get_type_of(self.loc, "global_var"), types.StringType) compare_types(self.type_store.get_type_of(self.loc, "global_func"), types.NoneType)
def test_create_union_type_with_modules(self): import math import sys import types union = UnionType.add(math, sys) compare_types(union, [math, sys]) clone = UnionType.add(math, sys) compare_types(union, clone.types) union2 = UnionType.add(clone, types) compare_types(union2, [math, sys, types]) self.assertFalse(union == union2)
def test_create_union_type_with_funcs(self): def foo(): pass union = UnionType.add(foo, range) compare_types(union, [foo, range]) union2 = UnionType(union, getattr) compare_types(union, [foo, range]) compare_types(union2, [foo, range, getattr]) self.assertFalse(union == union2) clone = UnionType.add(foo, range) self.assertTrue(union == clone)
def test_try_except_finally(self): self.context = self.context.open_ssa_context("try") self.context.set_type_of(self.localization, "var1", int) self.context.set_type_of(self.localization, "var2", float) self.context.open_ssa_branch("except") # except self.context.set_type_of(self.localization, "var1", str) self.context.set_type_of(self.localization, "var2", str) self.context.open_ssa_branch("finally") # except self.context.set_type_of(self.localization, "var1", list) self.context.set_type_of(self.localization, "var2", list) self.context.set_type_of(self.localization, "var3", list) self.context = self.context.join_ssa_context() compare_types(self.context.get_type_of(self.localization, "var1"), list) compare_types(self.context.get_type_of(self.localization, "var2"), list) compare_types(self.context.get_type_of(self.localization, "var3"), list)
def test_call_union_type(self): abs_func = self.context.get_type_of(self.localization, 'abs') union_valid = UnionType.create_from_type_list([True, complex()]) union_mixed = UnionType.create_from_type_list([int(), list()]) union_wrong = UnionType.create_from_type_list([dict(), list()]) # Two valid types ret = invoke(self.localization, abs_func, union_valid) compare_types(ret, [int(), float()]) # Two types: one valid, one invalid ret = invoke(self.localization, abs_func, union_mixed) compare_types(type(ret), int) assert len(TypeWarning.get_warning_msgs()) == 1 # Two invalid types ret = invoke(self.localization, abs_func, union_wrong) compare_types(type(ret), StypyTypeError) assert len(StypyTypeError.get_error_msgs()) == 1
def test_load_var_parent_context(self): self.type_store.set_type_of(self.loc, "var", int()) def fun(): pass self.type_store.set_type_of(self.loc, "func", fun) class Foo: pass self.type_store.set_type_of(self.loc, "Foo", Foo) self.type_store.set_type_of(self.loc, "Foo_instance", Foo()) import math self.type_store.set_type_of(self.loc, "math", math) self.type_store = self.type_store.open_function_context("new_func") compare_types(type(self.type_store.get_type_of(self.loc, "var")), types.IntType) compare_types(type(self.type_store.get_type_of(self.loc, "func")), types.FunctionType) compare_types(type(self.type_store.get_type_of(self.loc, "Foo")), types.ClassType) compare_types(type(self.type_store.get_type_of(self.loc, "Foo_instance")), types.InstanceType) compare_types(type(self.type_store.get_type_of(self.loc, "math")), types.ModuleType) self.type_store.set_type_of(self.loc, "other_var", float()) self.type_store = self.type_store.open_function_context("nested_func") compare_types(type(self.type_store.get_type_of(self.loc, "var")), types.IntType) compare_types(type(self.type_store.get_type_of(self.loc, "func")), types.FunctionType) compare_types(type(self.type_store.get_type_of(self.loc, "Foo")), types.ClassType) compare_types(type(self.type_store.get_type_of(self.loc, "Foo_instance")), types.InstanceType) compare_types(type(self.type_store.get_type_of(self.loc, "math")), types.ModuleType) self.type_store.set_type_of(self.loc, "even_other_var", list()) compare_types(type(self.type_store.get_type_of(self.loc, "other_var")), types.FloatType) self.type_store = self.type_store.open_function_context("other_nested_func") compare_types(type(self.type_store.get_type_of(self.loc, "var")), types.IntType) compare_types(type(self.type_store.get_type_of(self.loc, "func")), types.FunctionType) compare_types(type(self.type_store.get_type_of(self.loc, "Foo")), types.ClassType) compare_types(type(self.type_store.get_type_of(self.loc, "Foo_instance")), types.InstanceType) compare_types(type(self.type_store.get_type_of(self.loc, "math")), types.ModuleType) compare_types(type(self.type_store.get_type_of(self.loc, "even_other_var")), types.ListType) self.type_store = self.type_store.close_function_context() # End other_nested_func self.type_store = self.type_store.close_function_context() # End nested_func res = self.type_store.get_type_of(self.loc, "even_other_var") assert_if_not_error(res) self.type_store = self.type_store.close_function_context() # End new_func res = self.type_store.get_type_of(self.loc, "other_var") assert_if_not_error(res)
def test_load_builtin(self): res = self.type_store.get_type_of(self.loc, "list") compare_types(res, types.ListType) res = self.type_store.get_type_of(self.loc, "bool") compare_types(res, types.BooleanType) res = self.type_store.get_type_of(self.loc, "None") compare_types(res, types.NoneType) res = self.type_store.get_type_of(self.loc, "dict") compare_types(res, types.DictType) res = self.type_store.get_type_of(self.loc, "ArithmeticError") compare_types(res, ArithmeticError) res = self.type_store.get_type_of(self.loc, "range") compare_types(type(res), types.BuiltinFunctionType)
def test_change_base_types(self): # Set a member on non-modifiable types union1 = UnionType.add(int, str) union1.__bases__ = (int, ) self.assertTrue(len(StypyTypeError.get_error_msgs()) == 1) class Foo: def method(self): pass def method_2(self): pass class Foo2: def method(self): pass def method_2(self): pass # Set a member with some of the types of the union able to be modified union2 = UnionType.add(Foo(), str) union2.__bases__ = (Foo2, ) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1) # TypeWarning.print_warning_msgs() compare_types(union2.__bases__.types[0].contained_types, Foo2) compare_types(union2.__bases__.types[1].contained_types, str.__bases__[0]) TypeWarning.reset_warning_msgs() instance1 = Foo() union3 = UnionType.add(instance1, str) instance2 = Foo2() union3 = UnionType.add(instance2, union3) union3.__bases__ = (Foo2, ) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1) compare_types(union3.__bases__.types[0].contained_types, Foo2) compare_types(union3.__bases__.types[1].contained_types, str.__bases__[0]) #compare_types(union3.__bases__, [(Foo2,), str.__bases__]) TypeWarning.reset_warning_msgs() StypyTypeError.reset_error_msgs() # Set a member using all-modifiable types union4 = UnionType.add(Foo(), Foo()) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0) union4.__bases__ = (Foo2, ) self.assertTrue(len(StypyTypeError.get_error_msgs()) == 0) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0) ret = union4.__bases__ compare_types(ret, (Foo2, ))
def test_change_type(self): # Set a member on non-modifiable types union1 = UnionType.add(int, str) union1.__class__ = int self.assertTrue(len(StypyTypeError.get_error_msgs()) == 1) class Foo: def method(self): pass def method_2(self): pass class Foo2: def method(self): pass def method_2(self): pass # Set a member with some of the types of the union able to be modified union2 = UnionType.add(Foo(), str) union2.__class__ = Foo2 self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1) # TypeWarning.print_warning_msgs() union_types = map(lambda x: type(x), union2.get_types()) compare_types(union_types, [type(Foo2()), types.TypeType]) TypeWarning.reset_warning_msgs() instance1 = Foo() union3 = UnionType.add(instance1, str) instance2 = Foo2() union3 = UnionType.add(instance2, union3) union3.__class__ = Foo2 self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1) union_types = map(lambda x: type(x), union2.get_types()) compare_types(union_types, [type(Foo2()), types.TypeType]) TypeWarning.reset_warning_msgs() StypyTypeError.reset_error_msgs() # Set a member using all-modifiable types foo1 = Foo() foo2 = Foo() union4 = UnionType.add(foo1, foo2) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0) self.assertTrue(len(StypyTypeError.get_error_msgs()) == 0) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0) ret = union4 compare_types(ret, foo1)
def test_set_type_of_member(self): # Set a member on non-modifiable types union1 = UnionType.add(int, str) union1.foo = int self.assertTrue(len(StypyTypeError.get_error_msgs()) == 1) class Foo: def method(self): pass def method_2(self): pass class Foo2: def method(self): pass def method_2(self): pass # Set a member with some of the types of the union able to be modified union2 = UnionType.add(Foo, str) union2.member = str self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1) # TypeWarning.print_warning_msgs() compare_types(union2.member, str) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 2) TypeWarning.reset_warning_msgs() instance1 = Foo() union3 = UnionType.add(instance1, str) instance2 = Foo2() union3 = UnionType.add(instance2, union3) union3.member = str self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1) compare_types(union3.member, str) TypeWarning.reset_warning_msgs() StypyTypeError.reset_error_msgs() # Set a member using all-modifiable types union4 = UnionType.add(Foo, Foo2) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0) union4.member = float self.assertTrue(len(StypyTypeError.get_error_msgs()) == 0) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0) ret = union4.member compare_types(ret, float) def obj_func(cls): pass union4.class_method = types.MethodType(obj_func, union4) ret = union4.class_method compare_types(ret, types.MethodType(obj_func, union4))
def test_get_type_of_member(self): context = Context(None, __file__) # Access a member that none of the stored types has union1 = UnionType.add(int, str) ret = union1.foo assert_if_not_error(ret) class Foo: att1 = int def method(self): pass def method_2(self): pass class Foo2: att1 = float def method(self): pass def method_2(self): pass # Access a member that can be provided only by some of the types in the union union2 = UnionType.add(Foo, str) ret = union2.method self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1) TypeWarning.reset_warning_msgs() compare_types(ret, Foo.method) instance1 = Foo() union3 = UnionType.add(instance1, str) instance2 = Foo2() union3 = UnionType.add(instance2, union3) ret = union3.method self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1) compare_types(ret, [ instance1.method, instance2.method, ]) TypeWarning.reset_warning_msgs() # Access a member that can be provided by all the types in the union union4 = UnionType.add(Foo, Foo2) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0) ret = union4.method compare_types(ret, [Foo.method, Foo2.method]) ret = union4.att1 compare_types(ret, [int, float]) # Access a member that can be provided by all the types in the union (using only Python types) union5 = UnionType.add(int, str) self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0) context.set_type_of(self.loc, "union5", union5) # "__str__" is a special method so we have to use the context to access to it ret = context.get_type_of_member(self.loc, union5, "__str__") compare_types(ret, [int.__str__, str.__str__])
def test_merge_union_types(self): int_var = int def fun(): pass class Foo: def method(self): pass def method_2(self): pass class_var = Foo method_var = Foo.method instance_var = Foo() import math module_var = math union1 = UnionType.create_from_type_list([int_var, fun, class_var]) union2 = UnionType.create_from_type_list( [method_var, instance_var, module_var]) compare_types(union1, [int_var, fun, class_var]) compare_types(union2, [method_var, instance_var, module_var]) fused_union = UnionType.add(union1, union2) compare_types( fused_union, [int_var, fun, class_var, method_var, instance_var, module_var]) clone = UnionType.create_from_type_list( [int_var, fun, class_var, method_var, instance_var, module_var]) compare_types(fused_union, clone) method2_var = Foo.method_2 UnionType.add(clone, types) UnionType.add(clone, method2_var) compare_types( fused_union, [int_var, fun, class_var, method_var, instance_var, module_var]) compare_types(clone, [ int_var, fun, class_var, method_var, instance_var, module_var, method2_var, types ]) clone2 = UnionType.create_from_type_list([ int_var, fun, class_var, method_var, instance_var, module_var, method2_var, types ]) self.assertFalse(fused_union == clone) compare_types(clone2, clone)
def test_call_varargs(self): func = self.context.get_type_of(self.localization, "min") compare_types(type(func), types.BuiltinFunctionType) ret = invoke(self.localization, func, int(), int(), float(), list()) compare_types(ret, [int(), float(), list()])