From c0ac34175068192b46ba836bf603659cb12a969d Mon Sep 17 00:00:00 2001 From: Dave Halter Date: Sun, 9 Jan 2022 13:20:49 +0100 Subject: [PATCH] Replace some type comments with annotations This was necessary, back when we supported Python 3.5 --- test/completion/pep0484_generic_mismatches.py | 8 +-- test/completion/pep0484_generic_parameters.py | 50 +++++++++---------- .../pep0484_generic_passthroughs.py | 10 ++-- 3 files changed, 34 insertions(+), 34 deletions(-) diff --git a/test/completion/pep0484_generic_mismatches.py b/test/completion/pep0484_generic_mismatches.py index 6f765c99..c8b12af5 100644 --- a/test/completion/pep0484_generic_mismatches.py +++ b/test/completion/pep0484_generic_mismatches.py @@ -27,13 +27,13 @@ class PlainClass(object): tpl = ("1", 2) -tpl_typed = ("2", 3) # type: Tuple[str, int] +tpl_typed: Tuple[str, int] = ("2", 3) collection = {"a": 1} -collection_typed = {"a": 1} # type: Dict[str, int] +collection_typed: Dict[str, int] = {"a": 1} -list_of_ints = [42] # type: List[int] -list_of_funcs = [foo] # type: List[Callable[[T], T]] +list_of_ints: List[int] = [42] +list_of_funcs: List[Callable[[T], T]] = [foo] custom_generic = CustomGeneric(123.45) diff --git a/test/completion/pep0484_generic_parameters.py b/test/completion/pep0484_generic_parameters.py index 0be4e9cb..c5230d13 100644 --- a/test/completion/pep0484_generic_parameters.py +++ b/test/completion/pep0484_generic_parameters.py @@ -19,12 +19,12 @@ T_co = TypeVar('T_co', covariant=True) V = TypeVar('V') -just_float = 42. # type: float -optional_float = 42. # type: Optional[float] -list_of_ints = [42] # type: List[int] -list_of_floats = [42.] # type: List[float] -list_of_optional_floats = [x or None for x in list_of_floats] # type: List[Optional[float]] -list_of_ints_and_strs = [42, 'abc'] # type: List[Union[int, str]] +just_float: float = 42. +optional_float: Optional[float] = 42. +list_of_ints: List[int] = [42] +list_of_floats: List[float] = [42.] +list_of_optional_floats: List[Optional[float]] = [x or None for x in list_of_floats] +list_of_ints_and_strs: List[Union[int, str]] = [42, 'abc'] # Test that simple parameters are handled def list_t_to_list_t(the_list: List[T]) -> List[T]: @@ -48,7 +48,7 @@ for z in list_t_to_list_t(list_of_ints_and_strs): z -list_of_int_type = [int] # type: List[Type[int]] +list_of_int_type: List[Type[int]] = [int] # Test that nested parameters are handled def list_optional_t_to_list_t(the_list: List[Optional[T]]) -> List[T]: @@ -85,7 +85,7 @@ def optional_list_t_to_list_t(x: Optional[List[T]]) -> List[T]: return x if x is not None else [] -optional_list_float = None # type: Optional[List[float]] +optional_list_float: Optional[List[float]] = None for xc in optional_list_t_to_list_t(optional_list_float): #? float() xc @@ -134,7 +134,7 @@ def list_tuple_t_to_tuple_list_t(the_list: List[Tuple[T]]) -> Tuple[List[T], ... return tuple(list(x) for x in the_list) -list_of_int_tuples = [(x,) for x in list_of_ints] # type: List[Tuple[int]] +list_of_int_tuples: List[Tuple[int]] = [(x,) for x in list_of_ints] for b in list_tuple_t_to_tuple_list_t(list_of_int_tuples): #? int() @@ -145,7 +145,7 @@ def list_tuple_t_elipsis_to_tuple_list_t(the_list: List[Tuple[T, ...]]) -> Tuple return tuple(list(x) for x in the_list) -list_of_int_tuple_elipsis = [tuple(list_of_ints)] # type: List[Tuple[int, ...]] +list_of_int_tuple_elipsis: List[Tuple[int, ...]] = [tuple(list_of_ints)] for b in list_tuple_t_elipsis_to_tuple_list_t(list_of_int_tuple_elipsis): #? int() @@ -157,7 +157,7 @@ def foo(x: int) -> int: return x -list_of_funcs = [foo] # type: List[Callable[[int], int]] +list_of_funcs: List[Callable[[int], int]] = [foo] def list_func_t_to_list_func_type_t(the_list: List[Callable[[T], T]]) -> List[Callable[[Type[T]], T]]: def adapt(func: Callable[[T], T]) -> Callable[[Type[T]], T]: @@ -176,7 +176,7 @@ def bar(*a, **k) -> int: return len(a) + len(k) -list_of_funcs_2 = [bar] # type: List[Callable[..., int]] +list_of_funcs_2: List[Callable[..., int]] = [bar] def list_func_t_passthrough(the_list: List[Callable[..., T]]) -> List[Callable[..., T]]: return the_list @@ -187,7 +187,7 @@ for b in list_func_t_passthrough(list_of_funcs_2): b(None, x="x") -mapping_int_str = {42: 'a'} # type: Dict[int, str] +mapping_int_str: Dict[int, str] = {42: 'a'} # Test that mappings (that have more than one parameter) are handled def invert_mapping(mapping: Mapping[K, V]) -> Mapping[V, K]: @@ -210,11 +210,11 @@ first(mapping_int_str) #? str() first("abc") -some_str = NotImplemented # type: str +some_str: str = NotImplemented #? str() first(some_str) -annotated = [len] # type: List[ Callable[[Sequence[float]], int] ] +annotated: List[ Callable[[Sequence[float]], int] ] = [len] #? int() first(annotated)() @@ -237,7 +237,7 @@ for b in values(mapping_int_str): # # Tests that user-defined generic types are handled # -list_ints = [42] # type: List[int] +list_ints: List[int] = [42] class CustomGeneric(Generic[T_co]): def __init__(self, val: T_co) -> None: @@ -248,7 +248,7 @@ class CustomGeneric(Generic[T_co]): def custom(x: CustomGeneric[T]) -> T: return x.val -custom_instance = CustomGeneric(42) # type: CustomGeneric[int] +custom_instance: CustomGeneric[int] = CustomGeneric(42) #? int() custom(custom_instance) @@ -275,7 +275,7 @@ for x5 in wrap_custom(list_ints): # Test extraction of type from a nested custom generic type -list_custom_instances = [CustomGeneric(42)] # type: List[CustomGeneric[int]] +list_custom_instances: List[CustomGeneric[int]] = [CustomGeneric(42)] def unwrap_custom(iterable: Iterable[CustomGeneric[T]]) -> List[T]: return [x.val for x in iterable] @@ -303,7 +303,7 @@ for xg in unwrap_custom(CustomGeneric(s) for s in 'abc'): # Test extraction of type from type parameer nested within a custom generic type -custom_instance_list_int = CustomGeneric([42]) # type: CustomGeneric[List[int]] +custom_instance_list_int: CustomGeneric[List[int]] = CustomGeneric([42]) def unwrap_custom2(instance: CustomGeneric[Iterable[T]]) -> List[T]: return list(instance.val) @@ -326,7 +326,7 @@ class Specialised(Mapping[int, str]): pass -specialised_instance = NotImplemented # type: Specialised +specialised_instance: Specialised = NotImplemented #? int() first(specialised_instance) @@ -341,7 +341,7 @@ class ChildOfSpecialised(Specialised): pass -child_of_specialised_instance = NotImplemented # type: ChildOfSpecialised +child_of_specialised_instance: ChildOfSpecialised = NotImplemented #? int() first(child_of_specialised_instance) @@ -355,13 +355,13 @@ class CustomPartialGeneric1(Mapping[str, T]): pass -custom_partial1_instance = NotImplemented # type: CustomPartialGeneric1[int] +custom_partial1_instance: CustomPartialGeneric1[int] = NotImplemented #? str() first(custom_partial1_instance) -custom_partial1_unbound_instance = NotImplemented # type: CustomPartialGeneric1 +custom_partial1_unbound_instance: CustomPartialGeneric1 = NotImplemented #? str() first(custom_partial1_unbound_instance) @@ -371,7 +371,7 @@ class CustomPartialGeneric2(Mapping[T, str]): pass -custom_partial2_instance = NotImplemented # type: CustomPartialGeneric2[int] +custom_partial2_instance: CustomPartialGeneric2[int] = NotImplemented #? int() first(custom_partial2_instance) @@ -380,7 +380,7 @@ first(custom_partial2_instance) values(custom_partial2_instance)[0] -custom_partial2_unbound_instance = NotImplemented # type: CustomPartialGeneric2 +custom_partial2_unbound_instance: CustomPartialGeneric2 = NotImplemented #? [] first(custom_partial2_unbound_instance) diff --git a/test/completion/pep0484_generic_passthroughs.py b/test/completion/pep0484_generic_passthroughs.py index 7c7b8820..d16e8366 100644 --- a/test/completion/pep0484_generic_passthroughs.py +++ b/test/completion/pep0484_generic_passthroughs.py @@ -19,16 +19,16 @@ TTypeAny = TypeVar('TTypeAny', bound=Type[Any]) TCallable = TypeVar('TCallable', bound=Callable[..., Any]) untyped_list_str = ['abc', 'def'] -typed_list_str = ['abc', 'def'] # type: List[str] +typed_list_str: List[str] = ['abc', 'def'] untyped_tuple_str = ('abc',) -typed_tuple_str = ('abc',) # type: Tuple[str] +typed_tuple_str: Tuple[str] = ('abc',) untyped_tuple_str_int = ('abc', 4) -typed_tuple_str_int = ('abc', 4) # type: Tuple[str, int] +typed_tuple_str_int: Tuple[str, int] = ('abc', 4) -variadic_tuple_str = ('abc',) # type: Tuple[str, ...] -variadic_tuple_str_int = ('abc', 4) # type: Tuple[Union[str, int], ...] +variadic_tuple_str: Tuple[str, ...] = ('abc',) +variadic_tuple_str_int: Tuple[Union[str, int], ...] = ('abc', 4) def untyped_passthrough(x):