Refactor to pass fail func to bind_new instead

Author: sterliakov

mypy/semanal.py

@@ -451,13 +451,13 @@ def __init__(
         self.type_stack = []
         # Are the namespaces of classes being processed complete?
         self.incomplete_type_stack: list[bool] = []
+        self.tvar_scope = TypeVarLikeScope()
         self.function_stack = []
         self.block_depth = [0]
         self.loop_depth = [0]
         self.errors = errors
         self.modules = modules
         self.msg = MessageBuilder(errors, modules)
-        self.tvar_scope = TypeVarLikeScope(msg=self.msg)
         self.missing_modules = missing_modules
         self.missing_names = [set()]
         # These namespaces are still in process of being populated. If we encounter a
@@ -859,7 +859,7 @@ def file_context(
             self._is_stub_file = file_node.path.lower().endswith(".pyi")
             self._is_typeshed_stub_file = file_node.is_typeshed_file(options)
             self.globals = file_node.names
-            self.tvar_scope = TypeVarLikeScope(msg=self.msg)
+            self.tvar_scope = TypeVarLikeScope()
 
             self.named_tuple_analyzer = NamedTupleAnalyzer(options, self, self.msg)
             self.typed_dict_analyzer = TypedDictAnalyzer(options, self, self.msg)
@@ -2404,7 +2404,7 @@ def tvar_defs_from_tvars(
                 self.fail(
                     message_registry.TYPE_VAR_REDECLARED_IN_NESTED_CLASS.format(name), context
                 )
-            tvar_def = self.tvar_scope.bind_new(name, tvar_expr, context)
+            tvar_def = self.tvar_scope.bind_new(name, tvar_expr, self.fail, context)
             if last_tvar_name_with_default is not None and not tvar_def.has_default():
                 self.msg.tvar_without_default_type(
                     tvar_def.name, last_tvar_name_with_default, context
@@ -2433,7 +2433,7 @@ def get_and_bind_all_tvars(self, type_exprs: list[Expression]) -> list[TypeVarLi
                 tvars.setdefault(name, (expr, base_expr))
         tvar_defs = []
         for name, (tvar_expr, context) in tvars.items():
-            tvar_def = self.tvar_scope.bind_new(name, tvar_expr, context)
+            tvar_def = self.tvar_scope.bind_new(name, tvar_expr, self.fail, context)
             tvar_defs.append(tvar_def)
         return tvar_defs
 
@@ -7441,7 +7441,7 @@ def analyze_type_expr(self, expr: Expression) -> None:
         # them semantically analyzed, however, if they need to treat it as an expression
         # and not a type. (Which is to say, mypyc needs to do this.) Do the analysis
         # in a fresh tvar scope in order to suppress any errors about using type variables.
-        with self.tvar_scope_frame(TypeVarLikeScope(msg=self.msg)), self.allow_unbound_tvars_set():
+        with self.tvar_scope_frame(TypeVarLikeScope()), self.allow_unbound_tvars_set():
             expr.accept(self)
 
     def type_analyzer(

mypy/tvar_scope.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from mypy.messages import MessageBuilder
+from collections.abc import Callable
+from typing_extensions import TypeAlias as _TypeAlias
+
 from mypy.nodes import (
     Context,
     ParamSpecExpr,
@@ -23,14 +25,21 @@
     TypeVarType,
 )
 
+FailFunc: _TypeAlias = Callable[[str, Context], None]
+
 
 class TypeVarLikeDefaultFixer(TrivialSyntheticTypeTranslator):
     """Set namespace for all TypeVarLikeTypes types."""
 
     def __init__(
-        self, scope: TypeVarLikeScope, source_tv: TypeVarLikeExpr, context: Context
+        self,
+        scope: TypeVarLikeScope,
+        fail_func: FailFunc,
+        source_tv: TypeVarLikeExpr,
+        context: Context,
     ) -> None:
         self.scope = scope
+        self.fail_func = fail_func
         self.source_tv = source_tv
         self.context = context
         super().__init__()
@@ -60,7 +69,7 @@ def visit_type_alias_type(self, t: TypeAliasType) -> Type:
         return t
 
     def _report_unbound_tvar(self, tvar: TypeVarLikeType) -> None:
-        self.scope.msg.fail(
+        self.fail_func(
             f"Type variable {tvar.name} referenced in the default"
             f" of {self.source_tv.name} is unbound",
             self.context,
@@ -79,8 +88,6 @@ def __init__(
         is_class_scope: bool = False,
         prohibited: TypeVarLikeScope | None = None,
         namespace: str = "",
-        *,
-        msg: MessageBuilder,
     ) -> None:
         """Initializer for TypeVarLikeScope
 
@@ -97,7 +104,6 @@ def __init__(
         self.is_class_scope = is_class_scope
         self.prohibited = prohibited
         self.namespace = namespace
-        self.msg = msg
         if parent is not None:
             self.func_id = parent.func_id
             self.class_id = parent.class_id
@@ -120,20 +126,20 @@ def allow_binding(self, fullname: str) -> bool:
 
     def method_frame(self, namespace: str) -> TypeVarLikeScope:
         """A new scope frame for binding a method"""
-        return TypeVarLikeScope(self, False, None, namespace=namespace, msg=self.msg)
+        return TypeVarLikeScope(self, False, None, namespace=namespace)
 
     def class_frame(self, namespace: str) -> TypeVarLikeScope:
         """A new scope frame for binding a class. Prohibits *this* class's tvars"""
-        return TypeVarLikeScope(
-            self.get_function_scope(), True, self, namespace=namespace, msg=self.msg
-        )
+        return TypeVarLikeScope(self.get_function_scope(), True, self, namespace=namespace)
 
     def new_unique_func_id(self) -> TypeVarId:
         """Used by plugin-like code that needs to make synthetic generic functions."""
         self.func_id -= 1
         return TypeVarId(self.func_id)
 
-    def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr, context: Context) -> TypeVarLikeType:
+    def bind_new(
+        self, name: str, tvar_expr: TypeVarLikeExpr, fail_func: FailFunc, context: Context
+    ) -> TypeVarLikeType:
         if self.is_class_scope:
             self.class_id += 1
             i = self.class_id
@@ -146,7 +152,9 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr, context: Context) -> T
         # referenced variable is already in scope (textually precedes the definition we're
         # processing now).
         default = tvar_expr.default.accept(
-            TypeVarLikeDefaultFixer(self, tvar_expr, context=context)
+            TypeVarLikeDefaultFixer(
+                self, fail_func=fail_func, source_tv=tvar_expr, context=context
+            )
         )
 
         if isinstance(tvar_expr, TypeVarExpr):

mypy/typeanal.py

@@ -1561,7 +1561,9 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
                     # below happens at very early stage.
                     variables = []
                     for name, tvar_expr in self.find_type_var_likes(callable_args):
-                        variables.append(self.tvar_scope.bind_new(name, tvar_expr, t))
+                        variables.append(
+                            self.tvar_scope.bind_new(name, tvar_expr, self.fail_func, t)
+                        )
                     maybe_ret = self.analyze_callable_args_for_paramspec(
                         callable_args, ret_type, fallback
                     ) or self.analyze_callable_args_for_concatenate(
@@ -1833,7 +1835,7 @@ def bind_function_type_variables(
                 assert var_node, "Binding for function type variable not found within function"
                 var_expr = var_node.node
                 assert isinstance(var_expr, TypeVarLikeExpr)
-                binding = self.tvar_scope.bind_new(var.name, var_expr, fun_type)
+                binding = self.tvar_scope.bind_new(var.name, var_expr, self.fail_func, fun_type)
                 defs.append(binding)
             return tuple(defs), has_self_type
         typevars, has_self_type = self.infer_type_variables(fun_type)
@@ -1846,7 +1848,7 @@ def bind_function_type_variables(
             if not self.tvar_scope.allow_binding(tvar.fullname):
                 err_msg = message_registry.TYPE_VAR_REDECLARED_IN_NESTED_CLASS.format(name)
                 self.fail(err_msg.value, defn, code=err_msg.code)
-            binding = self.tvar_scope.bind_new(name, tvar, fun_type)
+            binding = self.tvar_scope.bind_new(name, tvar, self.fail_func, fun_type)
             defs.append(binding)
 
         return tuple(defs), has_self_type