Adapt __eq__ note:

* Use textwrap.dedent to have a nicer multiline string
* Only show the note for __eq__
* Use the actual class name in the shown code snippet
* Adapt the test

Author: David-Wobrock

mypy/messages.py

@@ -13,6 +13,7 @@
 from collections import OrderedDict
 import re
 import difflib
+from textwrap import dedent
 
 from typing import cast, List, Dict, Any, Sequence, Iterable, Tuple, Set, Optional, Union
 
@@ -868,20 +869,19 @@ def argument_incompatible_with_supertype(
         self.fail('Argument {} of "{}" incompatible with {}'
                   .format(arg_num, name, target), context)
 
-        if name in ("__eq__", "__ne__"):
-            multiline_msg = self.comparison_method_example_msg(name)
+        if name == "__eq__":
+            assert isinstance(context, FuncDef)
+            multiline_msg = self.comparison_method_example_msg(class_name=context.info.name())
             self.note_multiline(multiline_msg, context)
 
-    def comparison_method_example_msg(self, method_name: str) -> str:
-        return '''It is recommended for "{method_name}" to work with arbitrary objects.
-The snippet below shows an example of how you can implement "{method_name}":
-
-class Foo(...):
-    ...
-    def {method_name}(self, other: object) -> bool:
-        if not isinstance(other, Foo):
-            raise NotImplementedError
-        return <logic to compare two Foo instances>'''.format(method_name=method_name)
+    def comparison_method_example_msg(self, class_name: str) -> str:
+        return dedent('''\
+        It is recommended for "__eq__" to work with arbitrary objects, for example:
+            def __eq__(self, other: object) -> bool:
+                if not isinstance(other, {class_name}):
+                    raise NotImplementedError
+                return <logic to compare two {class_name} instances>
+        '''.format(class_name=class_name))
 
     def return_type_incompatible_with_supertype(
             self, name: str, name_in_supertype: str, supertype: str,

test-data/unit/check-classes.test

@@ -282,32 +282,17 @@ class B(A):
 main:7: error: Argument 1 of "f" incompatible with supertype "A"
 main:9: error: Return type of "h" incompatible with supertype "A"
 
-[case testEqNeMethodsOverridingWithNonObjects]
+[case testEqMethodsOverridingWithNonObjects]
 class A:
   def __eq__(self, other: A) -> bool: pass  # Fail
-  def __ne__(self, other: A) -> bool: pass  # Fail
 [builtins fixtures/attr.pyi]
 [out]
 main:2: error: Argument 1 of "__eq__" incompatible with supertype "object"
-main:2: note: It is recommended for "__eq__" to work with arbitrary objects.
-main:2: note: The snippet below shows an example of how you can implement "__eq__":
-main:2: note:
-main:2: note: class Foo(...):
-main:2: note:     ...
+main:2: note: It is recommended for "__eq__" to work with arbitrary objects, for example:
 main:2: note:     def __eq__(self, other: object) -> bool:
-main:2: note:         if not isinstance(other, Foo):
+main:2: note:         if not isinstance(other, A):
 main:2: note:             raise NotImplementedError
-main:2: note:         return <logic to compare two Foo instances>
-main:3: error: Argument 1 of "__ne__" incompatible with supertype "object"
-main:3: note: It is recommended for "__ne__" to work with arbitrary objects.
-main:3: note: The snippet below shows an example of how you can implement "__ne__":
-main:3: note:
-main:3: note: class Foo(...):
-main:3: note:     ...
-main:3: note:     def __ne__(self, other: object) -> bool:
-main:3: note:         if not isinstance(other, Foo):
-main:3: note:             raise NotImplementedError
-main:3: note:         return <logic to compare two Foo instances>
+main:2: note:         return <logic to compare two A instances>
 
 [case testMethodOverridingWithIncompatibleArgumentCount]
 import typing