address comments

Author: mkurnikov

mypy/checker.py

@@ -1605,7 +1605,7 @@ def check_multiple_inheritance(self, typ: TypeInfo) -> None:
                     if name in base2.names and base2 not in base.mro:
                         self.check_compatibility(name, base, base2, typ)
 
-    def _determine_type_of_class_member(self, sym: SymbolTableNode) -> Optional[Type]:
+    def determine_type_of_class_member(self, sym: SymbolTableNode) -> Optional[Type]:
         if sym.type is not None:
             return sym.type
         if isinstance(sym.node, FuncBase):
@@ -1629,18 +1629,41 @@ def check_compatibility(self, name: str, base1: TypeInfo,
         first = base1[name]
         second = base2[name]
         if isinstance(first.node, TypeInfo) and isinstance(second.node, TypeInfo):
-            # allow nested classes with the same name
+            # Checking compatibility of two nested classes with the same name is disabled.
+            # It creates a lot of false positives in frameworks like Django, DRF and others,
+            # where nested classes is used to define custom properties for the outer class, like
+            #     class MyModel:
+            #         class Meta:
+            #             abstract = True
+            #
+            # This is technically unsafe, it create false-negatives in cases like
+            # class Mixin1:
+            #     class Meta:
+            #         def get() -> int: pass
+            # class Mixin2:
+            #     class Meta:
+            #         def get() -> str: pass
+            # class A(Mixin2, Mixin1):
+            #     pass
+            # var: Mixin1 = A(); var.Meta.get()  # return type will be "str"
             return
-        first_type = self._determine_type_of_class_member(first)
-        second_type = self._determine_type_of_class_member(second)
+        first_type = self.determine_type_of_class_member(first)
+        second_type = self.determine_type_of_class_member(second)
 
         # TODO: What if some classes are generic?
         if (isinstance(first_type, FunctionLike) and
                 isinstance(second_type, FunctionLike)):
-            # Method override
-            first_sig = bind_self(first_type)
-            second_sig = bind_self(second_type)
-            ok = is_subtype(first_sig, second_sig, ignore_pos_arg_names=True)
+            if ((isinstance(first_type, CallableType)
+                 and first_type.fallback.type.fullname() == 'builtins.type')
+                    and (isinstance(second_type, CallableType)
+                         and second_type.fallback.type.fullname() == 'builtins.type')):
+                # Both members are classes (not necessary nested), check if compatible
+                ok = is_subtype(first_type.ret_type, second_type.ret_type)
+            else:
+                # Method override
+                first_sig = bind_self(first_type)
+                second_sig = bind_self(second_type)
+                ok = is_subtype(first_sig, second_sig, ignore_pos_arg_names=True)
         elif first_type and second_type:
             ok = is_equivalent(first_type, second_type)
         else:

test-data/unit/check-multiple-inheritance.test

@@ -273,4 +273,68 @@ class Mixin2:
 class A(Mixin1, Mixin2):
     pass
 [out]
-main:7: error: Definition of "Nested1" in base class "Mixin1" is incompatible with definition in base class "Mixin2"
+main:7: error: Definition of "Nested1" in base class "Mixin1" is incompatible with definition in base class "Mixin2"
+
+[case testMultipleInheritanceOneClassIsNestedAndAnotherIsRefToOther]
+class Outer:
+    pass
+class Mixin1:
+    class Nested1:
+        pass
+class Mixin2:
+    Nested1 = Outer
+class A(Mixin2, Mixin1):
+    pass
+[out]
+main:8: error: Definition of "Nested1" in base class "Mixin2" is incompatible with definition in base class "Mixin1"
+
+[case testNestedVariableRefersToSubclassesFromSameInheritanceChain]
+class A:
+    def __init__(self, arg: str) -> None:
+        pass
+class B(A):
+    pass
+class Base1:
+    NestedVar = A
+class Base2:
+    NestedVar = B
+class Combo(Base2, Base1): ...
+[out]
+
+[case testNestedVariableRefersToSuperlassUnderSubclass]
+class A:
+    def __init__(self, arg: str) -> None:
+        pass
+class B(A):
+    pass
+class Base1:
+    NestedVar = B
+class Base2:
+    NestedVar = A
+class Combo(Base2, Base1): ...
+[out]
+main:10: error: Definition of "NestedVar" in base class "Base2" is incompatible with definition in base class "Base1"
+
+[case testNestedVariableRefersToSubclassOfAnotherNestedClass]
+class Mixin1:
+    class Meta:
+        pass
+class Outer(Mixin1.Meta):
+    pass
+class Mixin2:
+    NestedVar = Outer
+class Combo(Mixin2, Mixin1): ...
+[out]
+
+[case testNestedVariableRefersToCompletelyDifferentClasses]
+class A:
+    pass
+class B:
+    pass
+class Base1:
+    NestedVar = A
+class Base2:
+    NestedVar = B
+class Combo(Base2, Base1): ...
+[out]
+main:9: error: Definition of "NestedVar" in base class "Base2" is incompatible with definition in base class "Base1"