Use tuple for callable type variables instead of Sequence

Author: JukkaL

mypy/applytype.py

@@ -243,7 +243,7 @@ def visit_callable_type(self, t: CallableType) -> Type:
         self.bound_tvars -= set(found_vars)
 
         assert isinstance(result, ProperType) and isinstance(result, CallableType)
-        result.variables = list(result.variables) + found_vars
+        result.variables = result.variables + tuple(found_vars)
         return result
 
     def visit_type_var(self, t: TypeVarType) -> Type:

mypy/plugins/common.py

@@ -360,7 +360,7 @@ def _add_method_by_spec(
 
     signature = CallableType(arg_types, arg_kinds, arg_names, return_type, function_type)
     if tvar_defs:
-        signature.variables = tvar_defs
+        signature.variables = tuple(tvar_defs)
 
     func = FuncDef(name, args, Block([PassStmt()]))
     func.info = info

mypy/semanal.py

@@ -995,7 +995,7 @@ def analyze_func_def(self, defn: FuncDef) -> None:
                     if has_self_type and self.type is not None:
                         info = self.type
                         if info.self_type is not None:
-                            result.variables = [info.self_type] + list(result.variables)
+                            result.variables = (info.self_type,) + result.variables
                 defn.type = result
                 self.add_type_alias_deps(analyzer.aliases_used)
                 self.check_function_signature(defn)

mypy/semanal_namedtuple.py

@@ -606,7 +606,7 @@ def add_method(
             arg_kinds = [arg.kind for arg in args]
             assert None not in types
             signature = CallableType(cast(list[Type], types), arg_kinds, items, ret, function_type)
-            signature.variables = [self_type]
+            signature.variables = (self_type,)
             func = FuncDef(funcname, args, Block([]))
             func.info = info
             func.is_class = is_classmethod

mypy/server/aststrip.py

@@ -165,7 +165,7 @@ def visit_func_def(self, node: FuncDef) -> None:
             # in order to get the state exactly as it was before semantic analysis.
             # See also #4814.
             assert isinstance(node.type, CallableType)
-            node.type.variables = []
+            node.type.variables = ()
         with self.enter_method(node.info) if node.info else nullcontext():
             super().visit_func_def(node)
 

mypy/typeanal.py

@@ -1820,7 +1820,7 @@ def infer_type_variables(
 
     def bind_function_type_variables(
         self, fun_type: CallableType, defn: Context
-    ) -> tuple[Sequence[TypeVarLikeType], bool]:
+    ) -> tuple[tuple[TypeVarLikeType, ...], bool]:
         """Find the type variables of the function type and bind them in our tvar_scope"""
         has_self_type = False
         if fun_type.variables:
@@ -1835,7 +1835,7 @@ def bind_function_type_variables(
                 assert isinstance(var_expr, TypeVarLikeExpr)
                 binding = self.tvar_scope.bind_new(var.name, var_expr)
                 defs.append(binding)
-            return defs, has_self_type
+            return tuple(defs), has_self_type
         typevars, has_self_type = self.infer_type_variables(fun_type)
         # Do not define a new type variable if already defined in scope.
         typevars = [
@@ -1849,7 +1849,7 @@ def bind_function_type_variables(
             binding = self.tvar_scope.bind_new(name, tvar)
             defs.append(binding)
 
-        return defs, has_self_type
+        return tuple(defs), has_self_type
 
     def is_defined_type_var(self, tvar: str, context: Context) -> bool:
         tvar_node = self.lookup_qualified(tvar, context)

mypy/types.py

@@ -2104,8 +2104,6 @@ def __init__(
     ) -> None:
         super().__init__(line, column)
         assert len(arg_types) == len(arg_kinds) == len(arg_names)
-        if variables is None:
-            variables = []
         self.arg_types = list(arg_types)
         for t in self.arg_types:
             if isinstance(t, ParamSpecType):
@@ -2123,7 +2121,11 @@ def __init__(
         #   * If it is a non-decorated function, FuncDef is the definition
         #   * If it is a decorated function, enclosing Decorator is the definition
         self.definition = definition
-        self.variables = variables
+        self.variables: tuple[TypeVarLikeType, ...]
+        if variables is None:
+            self.variables = ()
+        else:
+            self.variables = tuple(variables)
         self.is_ellipsis_args = is_ellipsis_args
         self.implicit = implicit
         self.special_sig = special_sig