Various changes

Author: cdce8p

mypy/expandtype.py

@@ -38,7 +38,7 @@
     flatten_nested_unions,
     get_proper_type,
     has_param_specs,
-    has_type_vars,
+    has_type_var_like_default,
     split_with_prefix_and_suffix,
 )
 from mypy.typevartuples import split_with_instance
@@ -231,11 +231,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_var_like_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/nodes.py

@@ -2853,6 +2853,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",
@@ -2957,6 +2958,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
 
@@ -3044,6 +3048,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 = []
@@ -3085,6 +3090,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):
@@ -3280,6 +3287,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],
@@ -3318,6 +3326,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

@@ -4154,7 +4154,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 = (
@@ -4422,7 +4422,7 @@ def process_paramspec_declaration(self, s: AssignmentStmt) -> bool:
             paramspec_var.line = call.line
             call.analyzed = paramspec_var
             updated = True
-            self.tvar_scope.bind_new(name, paramspec_var)
+            # self.tvar_scope.bind_new(name, paramspec_var)  # TODO!
         else:
             assert isinstance(call.analyzed, ParamSpecExpr)
             updated = default != call.analyzed.default
@@ -4491,6 +4491,7 @@ def process_typevartuple_declaration(self, s: AssignmentStmt) -> bool:
             typevartuple_var.line = call.line
             call.analyzed = typevartuple_var
             updated = True
+            # self.tvar_scope.bind_new(name, typevartuple_var)  # TODO!
         else:
             assert isinstance(call.analyzed, TypeVarTupleExpr)
             updated = default != call.analyzed.default

mypy/typeanal.py

@@ -430,7 +430,10 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
                     isinstance(res, ProperType)
                     and isinstance(res, Instance)
                     and not (self.defining_alias and self.nesting_level == 0)
-                    and not validate_instance(res, self.fail, t.empty_tuple_index)
+                    and (
+                        res.type.has_type_var_default
+                        or not validate_instance(res, self.fail, t.empty_tuple_index)
+                    )
                 ):
                     fix_instance(
                         res,
@@ -736,8 +739,9 @@ def analyze_type_with_type_info(
 
         # Check type argument count.
         instance.args = tuple(flatten_nested_tuples(instance.args))
-        if not (self.defining_alias and self.nesting_level == 0) and not validate_instance(
-            instance, self.fail, empty_tuple_index
+        if not (self.defining_alias and self.nesting_level == 0) and (
+            not validate_instance(instance, self.fail, empty_tuple_index)
+            or info.has_type_var_default
         ):
             fix_instance(
                 instance,

mypy/types.py

@@ -3496,6 +3496,30 @@ def has_type_vars(typ: Type) -> bool:
     return typ.accept(HasTypeVars())
 
 
+class HasTypeVarLikeDefault(BoolTypeQuery):
+    def __init__(self) -> None:
+        super().__init__(ANY_STRATEGY)
+        self.skip_alias_target = True
+
+    def visit_type_var(self, t: TypeVarType) -> bool:
+        return t.has_default()
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> bool:
+        return t.has_default()
+
+    def visit_param_spec(self, t: ParamSpecType) -> bool:
+        return t.has_default()
+
+
+# Use singleton since this is hot (note: call reset() before using)
+_has_type_var_like_default: Final = HasTypeVarLikeDefault()
+
+
+def has_type_var_like_default(typ: Type) -> bool:
+    _has_type_var_like_default.reset()
+    return typ.accept(_has_type_var_like_default)
+
+
 class HasParamSpecs(BoolTypeQuery):
     def __init__(self) -> None:
         super().__init__(ANY_STRATEGY)