fix handling of Type[M] + 0 where M is TypeVar

mypy/checkexpr.py

@@ -2445,9 +2445,14 @@ def has_member(self, typ: Type, member: str) -> bool:
         elif isinstance(typ, TypeType):
             # Type[Union[X, ...]] is always normalized to Union[Type[X], ...],
             # so we don't need to care about unions here.
-            if isinstance(typ.item, Instance) and typ.item.type.metaclass_type is not None:
-                return self.has_member(typ.item.type.metaclass_type, member)
-            if isinstance(typ.item, AnyType):
+            item = typ.item
+            if isinstance(item, TypeVarType):
+                item = item.upper_bound
+            if isinstance(item, TupleType):
+                item = item.fallback
+            if isinstance(item, Instance) and item.type.metaclass_type is not None:
+                return self.has_member(item.type.metaclass_type, member)
+            if isinstance(item, AnyType):
                 return True
             return False
         else:

test-data/unit/check-classes.test

@@ -3459,6 +3459,23 @@ class Concrete(metaclass=Meta):
 reveal_type(Concrete + X())  # E: Revealed type is 'builtins.str'
 Concrete + "hello"  # E: Unsupported operand types for + ("Type[Concrete]" and "str")
 
+[case testMetaclassOperatorTypeVar]
+from typing import Type, TypeVar
+
+class MetaClass(type):
+    def __mul__(cls, other: int) -> str:
+        return ""
+
+class Test(metaclass=MetaClass):
+    pass
+
+S = TypeVar("S", bound=Test)
+
+def f(x: Type[Test]) -> str:
+    return x * 0
+def g(x: Type[S]) -> str:
+    return x * 0
+
 [case testMetaclassGetitem]
 class M(type):
     def __getitem__(self, key) -> int: return 1

test-data/unit/lib-stub/builtins.pyi

@@ -7,6 +7,7 @@ class type:
 # These are provided here for convenience.
 class int:
     def __add__(self, other: 'int') -> 'int': pass
+    def __rmul__(self, other: 'int') -> 'int': pass
 class float: pass
 
 class str: