Make type comparisons work

This commit introduces a workaround to fix the bug discussed in
python#1787

Previously, code where you compared two types (eg `int == int`) would
cause mypy to incorrectly report a "too few arguments" error.

Author: MichaelLeeDBX

mypy/checkmember.py

@@ -91,10 +91,15 @@ def analyze_member_access(name: str, typ: Type, node: Context, is_lvalue: bool,
         if isinstance(ret_type, TupleType):
             ret_type = ret_type.fallback
         if isinstance(ret_type, Instance):
-            result = analyze_class_attribute_access(ret_type, name, node, is_lvalue,
-                                                    builtin_type, not_ready_callback, msg)
-            if result:
-                return result
+            if name not in {'__eq__', '__ne__'}:
+                # We skip here so that when mypy sees `type(foo) == type(bar)`, it doesn't try
+                # and typecheck against `foo.__eq__`. This workaround makes sure that mypy falls
+                # through and uses `foo.__class__.__eq__`.instead. See the bug discussed in
+                # https://github.com/python/mypy/pull/1787 for more info.
+                result = analyze_class_attribute_access(ret_type, name, node, is_lvalue,
+                                                        builtin_type, not_ready_callback, msg)
+                if result:
+                    return result
             # Look up from the 'type' type.
             return analyze_member_access(name, typ.fallback, node, is_lvalue, is_super,
                                          builtin_type, not_ready_callback, msg,
@@ -121,7 +126,8 @@ def analyze_member_access(name: str, typ: Type, node: Context, is_lvalue: bool,
         elif isinstance(typ.item, TypeVarType):
             if isinstance(typ.item.upper_bound, Instance):
                 item = typ.item.upper_bound
-        if item:
+        if item and name not in {'__eq__', '__ne__'}:
+            # See comment above for why __eq__ and __ne__ are skipped
             result = analyze_class_attribute_access(item, name, node, is_lvalue,
                                                     builtin_type, not_ready_callback, msg)
             if result:

test-data/unit/check-classes.test

@@ -2006,3 +2006,39 @@ reveal_type(User)  # E: Revealed type is 'builtins.type'
 [builtins fixtures/args.py]
 [out]
 
+[case testTypeTypeComparisonWorks]
+class User: pass
+
+User == User
+User == type(User())
+type(User()) == User
+type(User()) == type(User())
+
+User != User
+User != type(User())
+type(User()) != User
+type(User()) != type(User())
+
+int == int
+int == type(3)
+type(3) == int
+type(3) == type(3)
+
+int != int
+int != type(3)
+type(3) != int
+type(3) != type(3)
+
+User is User
+User is type(User)
+type(User) is User
+type(User) is type(User)
+
+int is int
+int is type(3)
+type(3) is int
+type(3) is type(3)
+[builtins fixtures/args.py]
+[out]
+
+

test-data/unit/fixtures/args.py

@@ -8,12 +8,15 @@
 
 class object:
     def __init__(self) -> None: pass
+    def __eq__(self, o: object) -> bool: pass
+    def __ne__(self, o: object) -> bool: pass
 
 class type:
     @overload
     def __init__(self, o: object) -> None: pass
     @overload
     def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: pass
+    def __call__(self, *args: Any, **kwargs: Any) -> Any: pass
 
 class tuple(Iterable[Tco], Generic[Tco]): pass
 class dict(Generic[T, S]): pass