Fix 1

Author: cdce8p

mypy/exprtotype.py

@@ -33,6 +33,7 @@
     Type,
     TypeList,
     TypeOfAny,
+    TypeOfTypeList,
     UnboundType,
     UnionType,
 )
@@ -161,9 +162,12 @@ def expr_to_unanalyzed_type(
             else:
                 raise TypeTranslationError()
         return CallableArgument(typ, name, arg_const, expr.line, expr.column)
-    elif isinstance(expr, ListExpr):
+    elif isinstance(expr, (ListExpr, TupleExpr)):
         return TypeList(
             [expr_to_unanalyzed_type(t, options, allow_new_syntax, expr) for t in expr.items],
+            TypeOfTypeList.callable_args
+            if isinstance(expr, ListExpr)
+            else TypeOfTypeList.param_spec_defaults,
             line=expr.line,
             column=expr.column,
         )

mypy/message_registry.py

@@ -179,7 +179,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 INVALID_TYPEVAR_ARG_BOUND: Final = 'Type argument {} of "{}" must be a subtype of {}'
 INVALID_TYPEVAR_ARG_VALUE: Final = 'Invalid type argument value for "{}"'
 TYPEVAR_VARIANCE_DEF: Final = 'TypeVar "{}" may only be a literal bool'
-TYPEVAR_ARG_MUST_BE_TYPE: Final = 'TypeVar "{}" must be a type'
+TYPEVAR_ARG_MUST_BE_TYPE: Final = '{} "{}" must be a type'
 TYPEVAR_UNEXPECTED_ARGUMENT: Final = 'Unexpected argument to "TypeVar()"'
 UNBOUND_TYPEVAR: Final = (
     "A function returning TypeVar should receive at least "

mypy/semanal.py

@@ -4096,12 +4096,14 @@ def process_typevar_parameters(
                 if has_values:
                     self.fail("TypeVar cannot have both values and an upper bound", context)
                     return None
-                tv_arg = self.get_typevarlike_argument(param_name, param_value, context)
+                tv_arg = self.get_typevarlike_argument("TypeVar", param_name, param_value, context)
                 if tv_arg is None:
                     return None
                 upper_bound = tv_arg
             elif param_name == "default":
-                tv_arg = self.get_typevarlike_argument(param_name, param_value, context)
+                tv_arg = self.get_typevarlike_argument(
+                    "TypeVar", param_name, param_value, context, allow_unbound_tvars=True
+                )
                 if tv_arg is None:
                     return None
                 default = tv_arg
@@ -4133,13 +4135,24 @@ def process_typevar_parameters(
         return variance, upper_bound, default
 
     def get_typevarlike_argument(
-        self, param_name: str, param_value: Expression, context: Context
+        self,
+        typevarlike_name: str,
+        param_name: str,
+        param_value: Expression,
+        context: Context,
+        *,
+        allow_unbound_tvars: bool = False,
+        allow_param_spec_literals: bool = False,
     ) -> ProperType | None:
         try:
             # We want to use our custom error message below, so we suppress
             # the default error message for invalid types here.
             analyzed = self.expr_to_analyzed_type(
-                param_value, allow_placeholder=True, report_invalid_types=False
+                param_value,
+                allow_placeholder=True,
+                report_invalid_types=False,
+                allow_unbound_tvars=allow_unbound_tvars,
+                allow_param_spec_literals=allow_param_spec_literals,
             )
             if analyzed is None:
                 # Type variables are special: we need to place them in the symbol table
@@ -4152,13 +4165,17 @@ def get_typevarlike_argument(
             typ = get_proper_type(analyzed)
             if isinstance(typ, AnyType) and typ.is_from_error:
                 self.fail(
-                    message_registry.TYPEVAR_ARG_MUST_BE_TYPE.format(param_name), param_value
+                    message_registry.TYPEVAR_ARG_MUST_BE_TYPE.format(typevarlike_name, param_name),
+                    param_value,
                 )
                 # Note: we do not return 'None' here -- we want to continue
                 # using the AnyType as the upper bound.
             return typ
         except TypeTranslationError:
-            self.fail(message_registry.TYPEVAR_ARG_MUST_BE_TYPE.format(param_name), param_value)
+            self.fail(
+                message_registry.TYPEVAR_ARG_MUST_BE_TYPE.format(typevarlike_name, param_name),
+                param_value,
+            )
             return None
 
     def extract_typevarlike_name(self, s: AssignmentStmt, call: CallExpr) -> str | None:
@@ -4202,10 +4219,30 @@ def process_paramspec_declaration(self, s: AssignmentStmt) -> bool:
             call.args[1 + n_values :], call.arg_names[1 + n_values :]
         ):
             if param_name == "default":
-                tv_arg = self.get_typevarlike_argument(param_name, param_value, s)
+                tv_arg = self.get_typevarlike_argument(
+                    "ParamSpec",
+                    param_name,
+                    param_value,
+                    s,
+                    allow_unbound_tvars=True,
+                    allow_param_spec_literals=True,
+                )
                 if tv_arg is None:
                     return False
                 default = tv_arg
+                if isinstance(tv_arg, Parameters):
+                    for i, arg_type in enumerate(tv_arg.arg_types):
+                        typ = get_proper_type(arg_type)
+                        if isinstance(typ, AnyType) and typ.is_from_error:
+                            self.fail(
+                                f"Argument {i} of ParamSpec default must be a type", param_value
+                            )
+                elif not isinstance(default, (AnyType, UnboundType)):
+                    self.fail(
+                        "The default argument to ParamSpec must be a tuple expression, ellipsis, or a ParamSpec",
+                        param_value,
+                    )
+                    default = AnyType(TypeOfAny.from_error)
             else:
                 # ParamSpec is different from a regular TypeVar:
                 # arguments are not semantically valid. But, allowed in runtime.
@@ -4252,15 +4289,18 @@ def process_typevartuple_declaration(self, s: AssignmentStmt) -> bool:
             call.args[1 + n_values :], call.arg_names[1 + n_values :]
         ):
             if param_name == "default":
-                tv_arg = self.get_typevarlike_argument(param_name, param_value, s)
+                tv_arg = self.get_typevarlike_argument(
+                    "TypeVarTuple", param_name, param_value, s, allow_unbound_tvars=True
+                )
                 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
+                        "The default argument to TypeVarTuple must be an Unpacked tuple",
+                        param_value,
                     )
-                    return False
+                    default = AnyType(TypeOfAny.from_error)
             else:
                 self.fail(
                     "The variance and bound arguments to TypeVarTuple do not have defined semantics yet",
@@ -6359,6 +6399,8 @@ def expr_to_analyzed_type(
         report_invalid_types: bool = True,
         allow_placeholder: bool = False,
         allow_type_any: bool = False,
+        allow_unbound_tvars: bool = False,
+        allow_param_spec_literals: bool = False,
     ) -> Type | None:
         if isinstance(expr, CallExpr):
             # This is a legacy syntax intended mostly for Python 2, we keep it for
@@ -6387,6 +6429,8 @@ def expr_to_analyzed_type(
             report_invalid_types=report_invalid_types,
             allow_placeholder=allow_placeholder,
             allow_type_any=allow_type_any,
+            allow_unbound_tvars=allow_unbound_tvars,
+            allow_param_spec_literals=allow_param_spec_literals,
         )
 
     def analyze_type_expr(self, expr: Expression) -> None:

mypy/typeanal.py

@@ -72,6 +72,7 @@
     TypedDictType,
     TypeList,
     TypeOfAny,
+    TypeOfTypeList,
     TypeQuery,
     TypeType,
     TypeVarLikeType,
@@ -890,10 +891,12 @@ def visit_type_list(self, t: TypeList) -> Type:
             else:
                 return AnyType(TypeOfAny.from_error)
         else:
+            s = "[...]" if t.list_type == TypeOfTypeList.callable_args else "(...)"
             self.fail(
-                'Bracketed expression "[...]" is not valid as a type', t, code=codes.VALID_TYPE
+                f'Bracketed expression "{s}" is not valid as a type', t, code=codes.VALID_TYPE
             )
-            self.note('Did you mean "List[...]"?', t)
+            if t.list_type == TypeOfTypeList.callable_args:
+                self.note('Did you mean "List[...]"?', t)
             return AnyType(TypeOfAny.from_error)
 
     def visit_callable_argument(self, t: CallableArgument) -> Type:

mypy/types.py

@@ -196,6 +196,17 @@ class TypeOfAny:
     suggestion_engine: Final = 9
 
 
+class TypeOfTypeList:
+    """This class describes the different types of TypeList."""
+
+    __slots__ = ()
+
+    # List expressions for callable args
+    callable_args: Final = 1
+    # Tuple expressions for ParamSpec defaults
+    param_spec_defaults: Final = 2
+
+
 def deserialize_type(data: JsonDict | str) -> Type:
     if isinstance(data, str):
         return Instance.deserialize(data)
@@ -991,13 +1002,20 @@ class TypeList(ProperType):
     types before they are processed into Callable types.
     """
 
-    __slots__ = ("items",)
+    __slots__ = ("items", "list_type")
 
     items: list[Type]
 
-    def __init__(self, items: list[Type], line: int = -1, column: int = -1) -> None:
+    def __init__(
+        self,
+        items: list[Type],
+        list_type: int = TypeOfTypeList.callable_args,
+        line: int = -1,
+        column: int = -1,
+    ) -> None:
         super().__init__(line, column)
         self.items = items
+        self.list_type = list_type
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         assert isinstance(visitor, SyntheticTypeVisitor)
@@ -1011,7 +1029,11 @@ def __hash__(self) -> int:
         return hash(tuple(self.items))
 
     def __eq__(self, other: object) -> bool:
-        return isinstance(other, TypeList) and self.items == other.items
+        return (
+            isinstance(other, TypeList)
+            and self.items == other.items
+            and self.list_type == other.list_type
+        )
 
 
 class UnpackType(ProperType):
@@ -3162,7 +3184,9 @@ def visit_callable_type(self, t: CallableType) -> str:
                             f"{var.name} <: {var.upper_bound.accept(self)}{f' = {var.default.accept(self)}' if var.has_default() else ''}"
                         )
                     else:
-                        vs.append(var.name)
+                        vs.append(
+                            f"{var.name}{f' = {var.default.accept(self)}' if var.has_default()  else ''}"
+                        )
                 else:
                     # For other TypeVarLikeTypes, use the name and default
                     vs.append(

test-data/unit/check-typevar-defaults.test

@@ -0,0 +1,73 @@
+[case testTypeVarDefaultsBasic]
+import builtins
+from typing import Generic, TypeVar, ParamSpec, Callable, Tuple, List
+from typing_extensions import TypeVarTuple, Unpack
+
+T1 = TypeVar("T1", default=int)
+P1 = ParamSpec("P1", default=(int, str))
+Ts1 = TypeVarTuple("Ts1", default=Unpack[Tuple[int, str]])
+
+def f1(a: T1) -> List[T1]: ...
+reveal_type(f1)  # N: Revealed type is "def [T1 = builtins.int] (a: T1`-1 = builtins.int) -> builtins.list[T1`-1 = builtins.int]"
+
+def f2(a: Callable[P1, None] ) -> Callable[P1, None]: ...
+reveal_type(f2)  # N: Revealed type is "def [P1 = [builtins.int, builtins.str]] (a: def (*P1.args, **P1.kwargs)) -> def (*P1.args, **P1.kwargs)"
+
+def f3(a: Tuple[Unpack[Ts1]]) -> Tuple[Unpack[Ts1]]: ...
+reveal_type(f3)  # N: Revealed type is "def [Ts1 = Unpack[Tuple[builtins.int, builtins.str]]] (a: Tuple[Unpack[Ts1`-1 = Unpack[Tuple[builtins.int, builtins.str]]]]) -> Tuple[Unpack[Ts1`-1 = Unpack[Tuple[builtins.int, builtins.str]]]]"
+
+
+class ClassA1(Generic[T1]): ...
+class ClassA2(Generic[P1]): ...
+class ClassA3(Generic[Unpack[Ts1]]): ...
+
+reveal_type(ClassA1)  # N: Revealed type is "def [T1 = builtins.int] () -> __main__.ClassA1[T1`1 = builtins.int]"
+reveal_type(ClassA2)  # N: Revealed type is "def [P1 = [builtins.int, builtins.str]] () -> __main__.ClassA2[P1`1 = [builtins.int, builtins.str]]"
+reveal_type(ClassA3)  # N: Revealed type is "def [Ts1 = Unpack[Tuple[builtins.int, builtins.str]]] () -> __main__.ClassA3[Unpack[Ts1`1 = Unpack[Tuple[builtins.int, builtins.str]]]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarDefaultsValid]
+from typing import TypeVar, ParamSpec, Any, List, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+S0 = TypeVar("S0")
+S1 = TypeVar("S1", bound=int)
+
+P0 = ParamSpec("P0")
+Ts0 = TypeVarTuple("Ts0")
+
+T1 = TypeVar("T1", default=int)
+T2 = TypeVar("T2", bound=float, default=int)
+T3 = TypeVar("T3", bound=List[Any], default=List[int])
+T4 = TypeVar("T4", int, str, default=int)
+T5 = TypeVar("T5", default=S0)
+T6 = TypeVar("T6", bound=float, default=S1)
+# T7 = TypeVar("T7", bound=List[Any], default=List[S0])  # TODO
+
+P1 = ParamSpec("P1", default=())
+P2 = ParamSpec("P2", default=...)
+P3 = ParamSpec("P3", default=(int, str))
+P4 = ParamSpec("P4", default=P0)
+
+Ts1 = TypeVarTuple("Ts1", default=Unpack[Tuple[int]])
+Ts2 = TypeVarTuple("Ts2", default=Unpack[Tuple[int, ...]])
+# Ts3 = TypeVarTuple("Ts3", default=Unpack[Ts0])  # TODO
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarDefaultsInvalid]
+from typing import TypeVar, ParamSpec, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+T1 = TypeVar("T1", default=2)  # E: TypeVar "default" must be a type
+T2 = TypeVar("T2", default=(int, str))  # E: Bracketed expression "(...)" is not valid as a type \
+                                        # E: TypeVar "default" must be a type
+
+P1 = ParamSpec("P1", default=int)  # E: The default argument to ParamSpec must be a tuple expression, ellipsis, or a ParamSpec
+P2 = ParamSpec("P2", default=2)  # E: ParamSpec "default" must be a type
+P3 = ParamSpec("P3", default=(2, int))  # E: Argument 0 of ParamSpec default must be a type
+
+Ts1 = TypeVarTuple("Ts1", default=2)  # E: TypeVarTuple "default" must be a type \
+                                      # E: The default argument to TypeVarTuple must be an Unpacked tuple
+Ts2 = TypeVarTuple("Ts2", default=int)  # E: The default argument to TypeVarTuple must be an Unpacked tuple
+Ts3 = TypeVarTuple("Ts3", default=Tuple[int])  # E: The default argument to TypeVarTuple must be an Unpacked tuple
+[builtins fixtures/tuple.pyi]

test-data/unit/semanal-errors.test

@@ -1045,7 +1045,7 @@ c = TypeVar(1)      # E: TypeVar() expects a string literal as first argument
 T = TypeVar(b'T')      # E: TypeVar() expects a string literal as first argument
 d = TypeVar('D')    # E: String argument 1 "D" to TypeVar(...) does not match variable name "d"
 e = TypeVar('e', int, str, x=1)   # E: Unexpected argument to "TypeVar()": "x"
-f = TypeVar('f', (int, str), int) # E: Type expected
+f = TypeVar('f', (int, str), int) # E: Bracketed expression "(...)" is not valid as a type
 g = TypeVar('g', int)             # E: TypeVar cannot have only a single constraint
 h = TypeVar('h', x=(int, str))    # E: Unexpected argument to "TypeVar()": "x"
 i = TypeVar('i', bound=1)         # E: TypeVar "bound" must be a type