Mypy micro-optimizations (batch 1/3) (#19768)

Several mypy micro-optimizations. Together with batches 2 and 3 these
improve self check performance by 1.8%.

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/binder.py

@@ -250,10 +250,12 @@ def update_from_options(self, frames: list[Frame]) -> bool:
         options are the same.
         """
         all_reachable = all(not f.unreachable for f in frames)
-        frames = [f for f in frames if not f.unreachable]
+        if not all_reachable:
+            frames = [f for f in frames if not f.unreachable]
         changed = False
-        keys = {key for f in frames for key in f.types}
-
+        keys = [key for f in frames for key in f.types]
+        if len(keys) > 1:
+            keys = list(set(keys))
         for key in keys:
             current_value = self._get(key)
             resulting_values = [f.types.get(key, current_value) for f in frames]

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/type_visitor.py

@@ -228,7 +228,7 @@ def visit_instance(self, t: Instance, /) -> Type:
             last_known_value = raw_last_known_value
         return Instance(
             typ=t.type,
-            args=self.translate_types(t.args),
+            args=self.translate_type_tuple(t.args),
             line=t.line,
             column=t.column,
             last_known_value=last_known_value,
@@ -242,7 +242,7 @@ def visit_param_spec(self, t: ParamSpecType, /) -> Type:
         return t
 
     def visit_parameters(self, t: Parameters, /) -> Type:
-        return t.copy_modified(arg_types=self.translate_types(t.arg_types))
+        return t.copy_modified(arg_types=self.translate_type_list(t.arg_types))
 
     def visit_type_var_tuple(self, t: TypeVarTupleType, /) -> Type:
         return t
@@ -255,14 +255,14 @@ def visit_unpack_type(self, t: UnpackType, /) -> Type:
 
     def visit_callable_type(self, t: CallableType, /) -> Type:
         return t.copy_modified(
-            arg_types=self.translate_types(t.arg_types),
+            arg_types=self.translate_type_list(t.arg_types),
             ret_type=t.ret_type.accept(self),
             variables=self.translate_variables(t.variables),
         )
 
     def visit_tuple_type(self, t: TupleType, /) -> Type:
         return TupleType(
-            self.translate_types(t.items),
+            self.translate_type_list(t.items),
             # TODO: This appears to be unsafe.
             cast(Any, t.partial_fallback.accept(self)),
             t.line,
@@ -299,7 +299,7 @@ def visit_union_type(self, t: UnionType, /) -> Type:
             return cached
 
         result = UnionType(
-            self.translate_types(t.items),
+            self.translate_type_list(t.items),
             t.line,
             t.column,
             uses_pep604_syntax=t.uses_pep604_syntax,
@@ -308,9 +308,12 @@ def visit_union_type(self, t: UnionType, /) -> Type:
             self.set_cached(t, result)
         return result
 
-    def translate_types(self, types: Iterable[Type]) -> list[Type]:
+    def translate_type_list(self, types: list[Type]) -> list[Type]:
         return [t.accept(self) for t in types]
 
+    def translate_type_tuple(self, types: tuple[Type, ...]) -> tuple[Type, ...]:
+        return tuple(t.accept(self) for t in types)
+
     def translate_variables(
         self, variables: Sequence[TypeVarLikeType]
     ) -> Sequence[TypeVarLikeType]:

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,14 +2104,12 @@ def __init__(
     ) -> None:
         super().__init__(line, column)
         assert len(arg_types) == len(arg_kinds) == len(arg_names)
-        for t, k in zip(arg_types, arg_kinds):
+        self.arg_types = list(arg_types)
+        for t in self.arg_types:
             if isinstance(t, ParamSpecType):
                 assert not t.prefix.arg_types
                 # TODO: should we assert that only ARG_STAR contain ParamSpecType?
                 # See testParamSpecJoin, that relies on passing e.g `P.args` as plain argument.
-        if variables is None:
-            variables = []
-        self.arg_types = list(arg_types)
         self.arg_kinds = arg_kinds
         self.arg_names = list(arg_names)
         self.min_args = arg_kinds.count(ARG_POS)
@@ -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