Fix some typing issues

cdce8p · cdce8p · commit 3f6736d4596a · 2022-12-31T09:28:07.000+01:00
diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -227,7 +227,7 @@ def _infer_constraints(template: Type, actual: Type, direction: int) -> list[Con
     if isinstance(actual, UnionType):
         actual = mypy.typeops.make_simplified_union(actual.items, keep_erased=True)
     if isinstance(actual, TypeVarType) and actual.has_default():
-        actual = actual.default
+        actual = get_proper_type(actual.default)
 
     # Ignore Any types from the type suggestion engine to avoid them
     # causing us to infer Any in situations where a better job could
diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -4017,13 +4017,15 @@ def process_typevar_parameters(
                 if has_values:
                     self.fail("TypeVar cannot have both values and an upper bound", context)
                     return None
-                upper_bound = self.get_typevarlike_argument(param_name, param_value, context)
-                if upper_bound is None:
+                tv_arg = self.get_typevarlike_argument(param_name, param_value, context)
+                if tv_arg is None:
                     return None
+                upper_bound = tv_arg
             elif param_name == "default":
-                default = self.get_typevarlike_argument(param_name, param_value, context)
-                if default is None:
+                tv_arg = self.get_typevarlike_argument(param_name, param_value, context)
+                if tv_arg is None:
                     return None
+                default = tv_arg
             elif param_name == "values":
                 # Probably using obsolete syntax with values=(...). Explain the current syntax.
                 self.fail('TypeVar "values" argument not supported', context)
@@ -4119,16 +4121,17 @@ def process_paramspec_declaration(self, s: AssignmentStmt) -> bool:
             return False
 
         n_values = call.arg_kinds[1:].count(ARG_POS)
-        default = AnyType(TypeOfAny.from_omitted_generics)
+        default: Type = AnyType(TypeOfAny.from_omitted_generics)
         for param_value, param_name, param_kind in zip(
             call.args[1 + n_values :],
             call.arg_names[1 + n_values :],
             call.arg_kinds[1 + n_values :],
         ):
             if param_name == "default":
-                default = self.get_typevarlike_argument(param_name, param_value, s)
-                if default is None:
+                tv_arg = self.get_typevarlike_argument(param_name, param_value, s)
+                if tv_arg is None:
                     return False
+                default = tv_arg
             else:
                 # ParamSpec is different from a regular TypeVar:
                 # arguments are not semantically valid. But, allowed in runtime.
@@ -4166,16 +4169,17 @@ def process_typevartuple_declaration(self, s: AssignmentStmt) -> bool:
             return False
 
         n_values = call.arg_kinds[1:].count(ARG_POS)
-        default = AnyType(TypeOfAny.from_omitted_generics)
+        default: Type = AnyType(TypeOfAny.from_omitted_generics)
         for param_value, param_name, param_kind in zip(
             call.args[1 + n_values :],
             call.arg_names[1 + n_values :],
             call.arg_kinds[1 + n_values :],
         ):
             if param_name == "default":
-                default = self.get_typevarlike_argument(param_name, param_value, s)
-                if default is None:
+                tv_arg = self.get_typevarlike_argument(param_name, param_value, s)
+                if tv_arg is None:
                     return False
+                default = tv_arg
                 if not isinstance(default, UnpackType):
                     self.fail(
                         "The default argument to TypeVarTuple must be an Unpacked tuple", default
diff --git a/mypy/test/testtypes.py b/mypy/test/testtypes.py
@@ -151,7 +151,7 @@ def test_generic_function_type(self) -> None:
         assert_equal(str(c), "def [X] (X?, Y?) -> Y?")
 
         v = [
-            TypeVarType("Y", "Y", -1, [], self.fx.o),
+            TypeVarType("Y", "Y", -1, [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics)),
             TypeVarType("X", "X", -2, [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics)),
         ]
         c2 = CallableType([], [], [], NoneType(), self.function, name=None, variables=v)
@@ -180,7 +180,7 @@ def test_type_alias_expand_all(self) -> None:
 
     def test_recursive_nested_in_non_recursive(self) -> None:
         A, _ = self.fx.def_alias_1(self.fx.a)
-        T = TypeVarType("T", "T", -1, [], self.fx.o)
+        T = TypeVarType("T", "T", -1, [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics))
         NA = self.fx.non_rec_alias(Instance(self.fx.gi, [T]), [T], [A])
         assert not NA.is_recursive
         assert has_recursive_types(NA)
diff --git a/mypy/test/typefixture.py b/mypy/test/typefixture.py
@@ -312,13 +312,32 @@ def make_type_info(
             v: list[TypeVarLikeType] = []
             for id, n in enumerate(typevars, 1):
                 if typevar_tuple_index is not None and id - 1 == typevar_tuple_index:
-                    v.append(TypeVarTupleType(n, n, id, self.o, self.std_tuple))
+                    v.append(
+                        TypeVarTupleType(
+                            n,
+                            n,
+                            id,
+                            self.o,
+                            self.std_tuple,
+                            AnyType(TypeOfAny.from_omitted_generics),
+                        )
+                    )
                 else:
                     if variances:
                         variance = variances[id - 1]
                     else:
                         variance = COVARIANT
-                    v.append(TypeVarType(n, n, id, [], self.o, variance=variance))
+                    v.append(
+                        TypeVarType(
+                            n,
+                            n,
+                            id,
+                            [],
+                            self.o,
+                            AnyType(TypeOfAny.from_omitted_generics),
+                            variance=variance,
+                        )
+                    )
             class_def.type_vars = v
 
         info = TypeInfo(SymbolTable(), class_def, module_name)
diff --git a/mypy/tvar_scope.py b/mypy/tvar_scope.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from copy import copy
-from typing import Generator
+from typing import Iterator
 
 from mypy.nodes import (
     ParamSpecExpr,
@@ -10,7 +10,7 @@
     TypeVarLikeExpr,
     TypeVarTupleExpr,
 )
-from mypy.type_visitor import SyntheticTypeVisitor, T
+from mypy.type_visitor import SyntheticTypeVisitor
 from mypy.types import (
     AnyType,
     CallableArgument,
@@ -45,96 +45,96 @@
 )
 
 
-class TypeVarLikeYielder(SyntheticTypeVisitor[Generator[TypeVarLikeType, None, None]]):
+class TypeVarLikeYielder(SyntheticTypeVisitor[Iterator[TypeVarLikeType]]):
     """Yield all TypeVarLikeTypes in a type."""
 
-    def visit_type_var(self, t: TypeVarType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_type_var(self, t: TypeVarType) -> Iterator[TypeVarLikeType]:
         yield t
 
-    def visit_type_var_tuple(self, t: TypeVarTupleType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> Iterator[TypeVarLikeType]:
         yield t
 
-    def visit_param_spec(self, t: ParamSpecType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_param_spec(self, t: ParamSpecType) -> Iterator[TypeVarLikeType]:
         yield t
 
-    def visit_callable_type(self, t: CallableType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_callable_type(self, t: CallableType) -> Iterator[TypeVarLikeType]:
         for arg in t.arg_types:
             yield from arg.accept(self)
         yield from t.ret_type.accept(self)
 
-    def visit_instance(self, t: Instance) -> Generator[TypeVarLikeType, None, None]:
+    def visit_instance(self, t: Instance) -> Iterator[TypeVarLikeType]:
         for arg in t.args:
             yield from arg.accept(self)
 
-    def visit_overloaded(self, t: Overloaded) -> Generator[TypeVarLikeType, None, None]:
+    def visit_overloaded(self, t: Overloaded) -> Iterator[TypeVarLikeType]:
         for item in t.items:
             yield from item.accept(self)
 
-    def visit_tuple_type(self, t: TupleType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_tuple_type(self, t: TupleType) -> Iterator[TypeVarLikeType]:
         for item in t.items:
             yield from item.accept(self)
 
-    def visit_type_alias_type(self, t: TypeAliasType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_type_alias_type(self, t: TypeAliasType) -> Iterator[TypeVarLikeType]:
         for arg in t.args:
             yield from arg.accept(self)
 
-    def visit_typeddict_type(self, t: TypedDictType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_typeddict_type(self, t: TypedDictType) -> Iterator[TypeVarLikeType]:
         for arg in t.items.values():
             yield from arg.accept(self)
 
-    def visit_union_type(self, t: UnionType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_union_type(self, t: UnionType) -> Iterator[TypeVarLikeType]:
         for arg in t.items:
             yield from arg.accept(self)
 
-    def visit_type_type(self, t: TypeType) -> T:
+    def visit_type_type(self, t: TypeType) -> Iterator[TypeVarLikeType]:
         yield from t.item.accept(self)
 
-    def visit_star_type(self, t: StarType) -> T:
+    def visit_star_type(self, t: StarType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_type_list(self, t: TypeList) -> T:
+    def visit_type_list(self, t: TypeList) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_callable_argument(self, t: CallableArgument) -> T:
+    def visit_callable_argument(self, t: CallableArgument) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_ellipsis_type(self, t: EllipsisType) -> T:
+    def visit_ellipsis_type(self, t: EllipsisType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_raw_expression_type(self, t: RawExpressionType) -> T:
+    def visit_raw_expression_type(self, t: RawExpressionType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_unbound_type(self, t: UnboundType) -> T:
+    def visit_unbound_type(self, t: UnboundType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_none_type(self, t: NoneType) -> T:
+    def visit_none_type(self, t: NoneType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_uninhabited_type(self, t: UninhabitedType) -> T:
+    def visit_uninhabited_type(self, t: UninhabitedType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_erased_type(self, t: ErasedType) -> T:
+    def visit_erased_type(self, t: ErasedType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_deleted_type(self, t: DeletedType) -> T:
+    def visit_deleted_type(self, t: DeletedType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_parameters(self, t: Parameters) -> T:
+    def visit_parameters(self, t: Parameters) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_literal_type(self, t: LiteralType) -> T:
+    def visit_literal_type(self, t: LiteralType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_partial_type(self, t: PartialType) -> T:
+    def visit_partial_type(self, t: PartialType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_unpack_type(self, t: UnpackType) -> T:
+    def visit_unpack_type(self, t: UnpackType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_any(self, t: AnyType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_any(self, t: AnyType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
-    def visit_placeholder_type(self, t: PlaceholderType) -> Generator[TypeVarLikeType, None, None]:
+    def visit_placeholder_type(self, t: PlaceholderType) -> Iterator[TypeVarLikeType]:
         yield from ()
 
 
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -385,6 +385,7 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
                     tvar_def.id,
                     tvar_def.upper_bound,
                     sym.node.tuple_fallback,
+                    tvar_def.default,
                     line=t.line,
                     column=t.column,
                 )
diff --git a/mypy/types.py b/mypy/types.py
@@ -583,6 +583,7 @@ def copy_modified(
         id: Bogus[TypeVarId | int] = _dummy,
         line: int = _dummy_int,
         column: int = _dummy_int,
+        **kwargs: Any,
     ) -> TypeVarType:
         return TypeVarType(
             self.name,
@@ -702,6 +703,7 @@ def copy_modified(
         flavor: int = _dummy_int,
         prefix: Bogus[Parameters] = _dummy,
         default: Bogus[Type] = _dummy,
+        **kwargs: Any,
     ) -> ParamSpecType:
         return ParamSpecType(
             self.name,
@@ -823,6 +825,7 @@ def copy_modified(
         id: Bogus[TypeVarId | int] = _dummy,
         upper_bound: Bogus[Type] = _dummy,
         default: Bogus[Type] = _dummy,
+        **kwargs: Any,
     ) -> TypeVarTupleType:
         return TypeVarTupleType(
             self.name,

Original file line number	Diff line number	Diff line change
`@@ -385,6 +385,7 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)`
`385`	`385`	`tvar_def.id,`
`386`	`386`	`tvar_def.upper_bound,`
`387`	`387`	`sym.node.tuple_fallback,`
	`388`	`+ tvar_def.default,`
`388`	`389`	`line=t.line,`
`389`	`390`	`column=t.column,`
`390`	`391`	`)`