Fix unsupported-binary-operation on classes that overload or

ChangeLog

@@ -87,6 +87,11 @@ Release date: TBA
 
   Closes #2409
 
+* Don't report ``unsupported-binary-operation`` on Python <= 3.9 when using the ``|`` operator
+  with types, if one has a metaclass that overloads ``__or__`` or ``__ror__`` as appropriate.
+
+  Closes #4951
+
 * The ``config`` attribute of ``BaseChecker`` has been deprecated. You can use ``checker.linter.config``
   to access the global configuration object instead of a checker-specific object.
 

doc/whatsnew/2.14.rst

@@ -256,6 +256,11 @@ Other Changes
 
   Relates to #6612
 
+* Don't report ``unsupported-binary-operation`` on Python <= 3.9 when using the ``|`` operator
+  with types, if one has a metaclass that overloads ``__or__`` or ``__ror__`` as appropriate.
+
+  Closes #4951
+
 * Fix bug where it writes a plain text error message to stdout, invalidating output formats.
 
   Closes #6597

pylint/checkers/typecheck.py

@@ -1900,13 +1900,34 @@ def _detect_unsupported_alternative_union_syntax(self, node: nodes.BinOp) -> Non
                 self._check_unsupported_alternative_union_syntax(node)
 
     def _check_unsupported_alternative_union_syntax(self, node: nodes.BinOp) -> None:
-        """Check if left or right node is of type `type`."""
+        """Check if left or right node is of type `type`.
+
+        If either is, and doesn't
+        support an or operator via a metaclass, infer that this is a mistaken
+        attempt to use alternative union syntax when not supported.
+        """
         msg = "unsupported operand type(s) for |"
-        for n in (node.left, node.right):
-            n = astroid.helpers.object_type(n)
-            if isinstance(n, nodes.ClassDef) and is_classdef_type(n):
-                self.add_message("unsupported-binary-operation", args=msg, node=node)
-                break
+        left_obj = astroid.helpers.object_type(node.left)
+        right_obj = astroid.helpers.object_type(node.right)
+        left_is_type = False
+        right_is_type = False
+
+        if isinstance(left_obj, nodes.ClassDef) and is_classdef_type(left_obj):
+            try:
+                left_obj.getattr("__or__")
+                return
+            except astroid.NotFoundError:
+                left_is_type = True
+
+        if isinstance(right_obj, nodes.ClassDef) and is_classdef_type(right_obj):
+            try:
+                right_obj.getattr("__ror__")
+                return
+            except astroid.NotFoundError:
+                right_is_type = True
+
+        if left_is_type or right_is_type:
+            self.add_message("unsupported-binary-operation", args=msg, node=node)
 
     # TODO: This check was disabled (by adding the leading underscore)
     # due to false positives several years ago - can we re-enable it?

tests/functional/a/alternative/alternative_union_syntax_error.py

@@ -87,3 +87,26 @@ class CustomDataClass3:
 @dataclasses.dataclass
 class CustomDataClass4:
     my_var: int | str  # [unsupported-binary-operation]
+
+# Not an error if the metaclass implements __or__
+
+class ForwardMetaclass(type):
+    def __or__(cls, other):
+        return True
+
+class ReverseMetaclass(type):
+    def __ror__(cls, other):
+        return True
+
+class WithForward(metaclass=ForwardMetaclass):
+    pass
+
+class WithReverse(metaclass=ReverseMetaclass):
+    pass
+
+class DefaultMetaclass:
+    pass
+
+class_list = [WithForward | DefaultMetaclass]
+class_list_reversed_invalid = [WithReverse | DefaultMetaclass] # [unsupported-binary-operation]
+class_list_reversed_valid = [DefaultMetaclass | WithReverse]

tests/functional/a/alternative/alternative_union_syntax_error.txt

@@ -22,3 +22,4 @@ unsupported-binary-operation:76:12:76:21:CustomDataClass:unsupported operand typ
 unsupported-binary-operation:80:12:80:21:CustomDataClass2:unsupported operand type(s) for |:UNDEFINED
 unsupported-binary-operation:84:12:84:21:CustomDataClass3:unsupported operand type(s) for |:UNDEFINED
 unsupported-binary-operation:89:12:89:21:CustomDataClass4:unsupported operand type(s) for |:UNDEFINED
+unsupported-binary-operation:111:31:111:61::unsupported operand type(s) for |:UNDEFINED