Refactoring: remove replacetvars.py

Remove the unused function replace_type_vars, and move the function
replace_func_type_vars to erasetype to share implementation with
erase_typevars.

Author: rwbarton

mypy/checkexpr.py

@@ -22,7 +22,7 @@
 import mypy.checker
 from mypy import types
 from mypy.sametypes import is_same_type
-from mypy.replacetvars import replace_func_type_vars
+from mypy.erasetype import replace_func_type_vars
 from mypy.messages import MessageBuilder
 from mypy import messages
 from mypy.infer import infer_type_arguments, infer_function_type_arguments

mypy/erasetype.py

@@ -1,4 +1,4 @@
-from typing import Optional, Container
+from typing import Optional, Container, Callable
 
 from mypy.types import (
     Type, TypeVisitor, UnboundType, ErrorType, AnyType, Void, NoneTyp, TypeVarId,
@@ -109,16 +109,26 @@ def erase_typevars(t: Type, ids_to_erase: Optional[Container[TypeVarId]] = None)
     """Replace all type variables in a type with any,
     or just the ones in the provided collection.
     """
-    return t.accept(TypeVarEraser(ids_to_erase))
+    def erase_id(id: TypeVarId) -> bool:
+        if ids_to_erase is None:
+            return True
+        return id in ids_to_erase
+    return t.accept(TypeVarEraser(erase_id, AnyType()))
+
+
+def replace_func_type_vars(t: Type, target_type: Type) -> Type:
+    """Replace function type variables in a type with the target type."""
+    return t.accept(TypeVarEraser(lambda id: id.is_func_var(), target_type))
 
 
 class TypeVarEraser(TypeTranslator):
     """Implementation of type erasure"""
 
-    def __init__(self, ids_to_erase: Optional[Container[TypeVarId]]) -> None:
-        self.ids_to_erase = ids_to_erase
+    def __init__(self, erase_id: Callable[[TypeVarId], bool], replacement: Type) -> None:
+        self.erase_id = erase_id
+        self.replacement = replacement
 
     def visit_type_var(self, t: TypeVarType) -> Type:
-        if self.ids_to_erase is not None and t.id not in self.ids_to_erase:
-            return t
-        return AnyType()
+        if self.erase_id(t.id):
+            return self.replacement
+        return t

mypy/replacetvars.py

@@ -14,7 +14,6 @@
     Instance, NoneTyp, ErrorType, Overloaded, TypeType,
 )
 from mypy.nodes import ARG_POS, ARG_OPT, ARG_STAR, CONTRAVARIANT, INVARIANT, COVARIANT
-from mypy.replacetvars import replace_type_vars
 from mypy.subtypes import is_subtype, is_more_precise, is_proper_subtype
 from mypy.typefixture import TypeFixture, InterfaceTypeFixture
 
@@ -132,25 +131,6 @@ def assert_expand(self, orig, map_items, result):
         # Remove erased tags (asterisks).
         assert_equal(str(exp).replace('*', ''), str(result))
 
-    # replace_type_vars
-
-    def test_trivial_replace(self):
-        for t in (self.fx.a, self.fx.o, self.fx.void, self.fx.nonet,
-                  self.tuple(self.fx.a),
-                  self.callable([], self.fx.a, self.fx.a), self.fx.anyt,
-                  self.fx.err):
-            self.assert_replace(t, t)
-
-    def test_replace_type_var(self):
-        self.assert_replace(self.fx.t, self.fx.anyt)
-
-    def test_replace_generic_instance(self):
-        self.assert_replace(self.fx.ga, self.fx.ga)
-        self.assert_replace(self.fx.gt, self.fx.gdyn)
-
-    def assert_replace(self, orig, result):
-        assert_equal(str(replace_type_vars(orig)), str(result))
-
     # erase_type
 
     def test_trivial_erase(self):

mypy/test/testtypes.py

@@ -70,6 +70,12 @@ def __ne__(self, other: object) -> bool:
     def __hash__(self) -> int:
         return hash(self.raw_id)
 
+    def is_class_var(self) -> bool:
+        return self.raw_id > 0
+
+    def is_func_var(self) -> bool:
+        return self.raw_id < 0
+
 
 class TypeVarDef(mypy.nodes.Context):
     """Definition of a single type variable."""
@@ -411,12 +417,6 @@ def __init__(self, binder: TypeVarDef, line: int = -1) -> None:
     def accept(self, visitor: 'TypeVisitor[T]') -> T:
         return visitor.visit_type_var(self)
 
-    def is_class_var(self) -> bool:
-        return self.id.raw_id > 0
-
-    def is_func_var(self) -> bool:
-        return self.id.raw_id < 0
-
     def erase_to_union_or_bound(self) -> Type:
         if self.values:
             return UnionType.make_simplified_union(self.values)