Corner case -- recursive TypeVar T

ilyalabun · ilyalabun · commit 4c78757498d0 · 2021-11-07T22:10:07.000+01:00
Corner case -- recursive TypeVar `T` with upper bound having
`__getitem__` method with `self` having type `T` and returning `T`.
In this case when we call `visit_index_with_type` recursively, `TypeVar`
types of upper bound `__getitem__` method are erased and
`check_method_call_by_name` returns type of upper bound, not `T`. So we
don't do recursive `visit_index_with_type` call when upper bound has
`__getitem__` method and handle this case in `else` branch. which
handles it as expected -- it return `T` as return type.
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -50,7 +50,7 @@
 )
 from mypy import join
 from mypy.meet import narrow_declared_type, is_overlapping_types
-from mypy.subtypes import is_subtype, is_proper_subtype, is_equivalent, non_method_protocol_members
+from mypy.subtypes import find_member, is_subtype, is_proper_subtype, is_equivalent, non_method_protocol_members
 from mypy import applytype
 from mypy import erasetype
 from mypy.checkmember import analyze_member_access, type_object_type
@@ -2960,7 +2960,8 @@ def visit_index_with_type(self, left_type: Type, e: IndexExpr,
         elif (isinstance(left_type, CallableType)
               and left_type.is_type_obj() and left_type.type_object().is_enum):
             return self.visit_enum_index_expr(left_type.type_object(), e.index, e)
-        elif isinstance(left_type, TypeVarType):
+        elif (isinstance(left_type, TypeVarType) 
+              and not self.has_member(left_type.upper_bound, "__getitem__")):
             return self.visit_index_with_type(left_type.upper_bound, e, original_type)
         else:
             result, method_type = self.check_method_call_by_name(
diff --git a/test-data/unit/check-typevar-values.test b/test-data/unit/check-typevar-values.test
@@ -679,3 +679,26 @@ def f(data: T) -> None:
     _: Union[str, int] = data["x"]
 [builtins fixtures/tuple.pyi]
 [builtins fixtures/dict.pyi]
+
+[case testSelfTypeVarIndexExpr]
+from typing import TypeVar, Union, Type
+from typing_extensions import TypedDict
+
+T = TypeVar("T", bound="Indexable")
+
+class Indexable:
+    def __init__(self, index: str) -> None:
+        self.index = index 
+
+    def __getitem__(self: T, index: str) -> T:
+        return self._new_instance(index)
+
+    @classmethod
+    def _new_instance(cls: Type[T], index: str) -> T:
+        return cls("foo")
+
+    def m(self: T) -> T:
+        return self["foo"]
+
+[builtins fixtures/tuple.pyi]
+[builtins fixtures/classmethod.pyi]
