Various changes

Author: cdce8p

mypy/applytype.py

@@ -104,14 +104,14 @@ def apply_generic_arguments(
             tvar, type, callable, report_incompatible_typevar_value, context, skip_unsatisfied
         )
         if isinstance(target_type, UninhabitedType) and tvar.has_default():
-            if isinstance(tvar.default, TypeVarLikeType):
-                id_to_type[tvar.id] = id_to_type[tvar.default.id]
-            else:
-                id_to_type[tvar.id] = tvar.default
-        elif isinstance(target_type, TypeVarLikeType) and isinstance(
-            target_type.default, TypeVarLikeType
-        ):
-            id_to_type[target_type.id] = id_to_type[target_type.default.id]
+            # if isinstance(tvar.default, TypeVarLikeType):
+            #     id_to_type[tvar.id] = id_to_type[tvar.default.id]
+            # else:
+            id_to_type[tvar.id] = tvar.default
+        # elif isinstance(target_type, TypeVarLikeType) and isinstance(
+        #     target_type.default, TypeVarLikeType
+        # ):
+        #     id_to_type[target_type.id] = id_to_type[target_type.default.id]
         elif target_type is not None:
             id_to_type[tvar.id] = target_type
 

mypy/checkexpr.py

@@ -5255,6 +5255,16 @@ def visit_callable_type(self, t: CallableType) -> bool:
             return False
         return super().visit_callable_type(t)
 
+    def visit_type_var(self, t: TypeVarType) -> bool:
+        # Exclude t.default - the default value for t.default is Any
+        return self.query_types([t.upper_bound] + t.values)
+
+    def visit_param_spec(self, t: ParamSpecType) -> bool:
+        return self.default
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> bool:
+        return self.default
+
 
 def has_coroutine_decorator(t: Type) -> bool:
     """Whether t came from a function decorated with `@coroutine`."""

mypy/expandtype.py

@@ -38,7 +38,7 @@
     flatten_nested_unions,
     get_proper_type,
     has_param_specs,
-    has_type_vars,
+    has_type_vars_default,
     remove_trivial,
 )
 from mypy.typevartuples import (
@@ -228,11 +228,13 @@ def visit_type_var(self, t: TypeVarType) -> Type:
             t = t.copy_modified(upper_bound=t.upper_bound.accept(self))
         repl = self.variables.get(t.id, t)
 
-        if has_type_vars(repl) and not isinstance(repl, Instance):
-            if repl in self.recursive_guard:  # or isinstance(repl, CallableType):
+        if has_type_vars_default(repl):
+            if repl in self.recursive_guard:
                 return repl
             self.recursive_guard.add(repl)
             repl = repl.accept(self)
+            if isinstance(repl, TypeVarType):
+                repl.default = repl.default.accept(self)
 
         if isinstance(repl, Instance):
             # TODO: do we really need to do this?

mypy/exprtotype.py

@@ -33,6 +33,7 @@
     Type,
     TypeList,
     TypeOfAny,
+    TypeOfTypeList,
     UnboundType,
     UnionType,
 )
@@ -164,6 +165,9 @@ def expr_to_unanalyzed_type(
     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_default,
             line=expr.line,
             column=expr.column,
         )

mypy/messages.py

@@ -2771,12 +2771,15 @@ def for_function(callee: CallableType) -> str:
     return ""
 
 
-def wrong_type_arg_count(n: int, act: str, name: str) -> str:
-    s = f"{n} type arguments"
-    if n == 0:
-        s = "no type arguments"
-    elif n == 1:
-        s = "1 type argument"
+def wrong_type_arg_count(low: int, high: int, act: str, name: str) -> str:
+    if low == high:
+        s = f"{low} type arguments"
+        if low == 0:
+            s = "no type arguments"
+        elif low == 1:
+            s = "1 type argument"
+    else:
+        s = f"between {low} and {high} type arguments"
     if act == "0":
         act = "none"
     return f'"{name}" expects {s}, but {act} given'

mypy/nodes.py

@@ -2826,6 +2826,7 @@ class is generic then it will be a type constructor of higher kind.
         "fallback_to_any",
         "meta_fallback_to_any",
         "type_vars",
+        "has_type_var_default",
         "has_param_spec_type",
         "bases",
         "_promote",
@@ -2928,6 +2929,9 @@ class is generic then it will be a type constructor of higher kind.
     # Generic type variable names (full names)
     type_vars: list[str]
 
+    # Whether this class has a TypeVar with a default value
+    has_type_var_default: bool
+
     # Whether this class has a ParamSpec type variable
     has_param_spec_type: bool
 
@@ -3009,6 +3013,7 @@ def __init__(self, names: SymbolTable, defn: ClassDef, module_name: str) -> None
         self.defn = defn
         self.module_name = module_name
         self.type_vars = []
+        self.has_type_var_default = False
         self.has_param_spec_type = False
         self.has_type_var_tuple_type = False
         self.bases = []
@@ -3048,6 +3053,8 @@ def add_type_vars(self) -> None:
         self.has_type_var_tuple_type = False
         if self.defn.type_vars:
             for i, vd in enumerate(self.defn.type_vars):
+                if vd.has_default():
+                    self.has_type_var_default = True
                 if isinstance(vd, mypy.types.ParamSpecType):
                     self.has_param_spec_type = True
                 if isinstance(vd, mypy.types.TypeVarTupleType):
@@ -3242,6 +3249,7 @@ def serialize(self) -> JsonDict:
             "defn": self.defn.serialize(),
             "abstract_attributes": self.abstract_attributes,
             "type_vars": self.type_vars,
+            "has_type_var_default": self.has_type_var_default,
             "has_param_spec_type": self.has_param_spec_type,
             "bases": [b.serialize() for b in self.bases],
             "mro": [c.fullname for c in self.mro],
@@ -3274,6 +3282,7 @@ def deserialize(cls, data: JsonDict) -> TypeInfo:
         # TODO: Is there a reason to reconstruct ti.subtypes?
         ti.abstract_attributes = [(attr[0], attr[1]) for attr in data["abstract_attributes"]]
         ti.type_vars = data["type_vars"]
+        ti.has_type_var_default = data["has_type_var_default"]
         ti.has_param_spec_type = data["has_param_spec_type"]
         ti.bases = [mypy.types.Instance.deserialize(b) for b in data["bases"]]
         _promote = []

mypy/semanal.py

@@ -178,7 +178,7 @@
     type_aliases_source_versions,
     typing_extensions_aliases,
 )
-from mypy.options import Options
+from mypy.options import TYPE_VAR_TUPLE, Options
 from mypy.patterns import (
     AsPattern,
     ClassPattern,
@@ -3996,7 +3996,7 @@ def process_typevar_declaration(self, s: AssignmentStmt) -> bool:
             type_var.line = call.line
             call.analyzed = type_var
             updated = True
-            # self.tvar_scope.bind_new(name, type_var)
+            # self.tvar_scope.bind_new(name, type_var)  # TODO!
         else:
             assert isinstance(call.analyzed, TypeVarExpr)
             updated = (
@@ -4196,6 +4196,9 @@ def process_paramspec_declaration(self, s: AssignmentStmt) -> bool:
             return False
 
         n_values = call.arg_kinds[1:].count(ARG_POS)
+        if n_values != 0:
+            self.fail("Only the first positional argument to ParamSpec has defined semantics", s)
+
         default: Type = AnyType(TypeOfAny.from_omitted_generics)
         for param_value, param_name, param_kind in zip(
             call.args[1 + n_values :],
@@ -4226,7 +4229,7 @@ def process_paramspec_declaration(self, s: AssignmentStmt) -> bool:
             )
             paramspec_var.line = call.line
             call.analyzed = paramspec_var
-            self.tvar_scope.bind_new(name, paramspec_var)
+            # self.tvar_scope.bind_new(name, paramspec_var)  # TODO!
         else:
             assert isinstance(call.analyzed, ParamSpecExpr)
         self.add_symbol(name, call.analyzed, s)
@@ -4244,6 +4247,11 @@ def process_typevartuple_declaration(self, s: AssignmentStmt) -> bool:
             return False
 
         n_values = call.arg_kinds[1:].count(ARG_POS)
+        if n_values != 0:
+            self.fail(
+                "Only the first positional argument to TypeVarTuple has defined semantics", s
+            )
+
         default: Type = AnyType(TypeOfAny.from_omitted_generics)
         for param_value, param_name, param_kind in zip(
             call.args[1 + n_values :],
@@ -4266,8 +4274,8 @@ def process_typevartuple_declaration(self, s: AssignmentStmt) -> bool:
                     s,
                 )
 
-        # if not self.incomplete_feature_enabled(TYPE_VAR_TUPLE, s):
-        #     return False
+        if not self.incomplete_feature_enabled(TYPE_VAR_TUPLE, s):
+            return False
 
         name = self.extract_typevarlike_name(s, call)
         if name is None:
@@ -4286,6 +4294,7 @@ def process_typevartuple_declaration(self, s: AssignmentStmt) -> bool:
             )
             typevartuple_var.line = call.line
             call.analyzed = typevartuple_var
+            # self.tvar_scope.bind_new(name, typevartuple_var)  # TODO!
         else:
             assert isinstance(call.analyzed, TypeVarTupleExpr)
         self.add_symbol(name, call.analyzed, s)

mypy/type_visitor.py

@@ -490,10 +490,10 @@ def visit_type_var(self, t: TypeVarType) -> bool:
         return self.query_types([t.upper_bound, t.default] + t.values)
 
     def visit_param_spec(self, t: ParamSpecType) -> bool:
-        return self.default
+        return t.default.accept(self)
 
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> bool:
-        return self.default
+        return t.default.accept(self)
 
     def visit_unpack_type(self, t: UnpackType) -> bool:
         return self.query_types([t.type])