Remove redundant comparison check code in visit_comparison_expr

Co-authored-by: m-aciek <9288014+m-aciek@users.noreply.github.com>

Author: Copilot

mypy/checkexpr.py

@@ -3697,12 +3697,6 @@ def visit_comparison_expr(self, e: ComparisonExpr) -> Type:
                     )
                     e.method_types.append(method_type)
 
-                # Check for unsafe subtype relationships if enabled
-                if not w.has_new_errors() and codes.UNSAFE_SUBTYPE in self.chk.options.enabled_error_codes:
-                    right_type = self.accept(right)
-                    if self.has_unsafe_subtype_relationship(left_type, right_type):
-                        self.msg.unsafe_subtype_comparison(left_type, right_type, operator, e)
-
                 # Only show dangerous overlap if there are no other errors. See
                 # testCustomEqCheckStrictEquality for an example.
                 if not w.has_new_errors() and operator in ("==", "!="):
@@ -3881,32 +3875,6 @@ def dangerous_comparison(
                 return False
         return not is_overlapping_types(left, right, ignore_promotions=False)
 
-    def has_unsafe_subtype_relationship(self, left: Type, right: Type) -> bool:
-        """Check if left and right have an unsafe subtyping relationship.
-
-        Returns True if they are instances with a nominal subclass relationship
-        that is known to be unsafe (e.g., datetime and date).
-        """
-        from mypy.subtypes import UNSAFE_SUBTYPING_PAIRS
-
-        left = get_proper_type(left)
-        right = get_proper_type(right)
-
-        if not isinstance(left, Instance) or not isinstance(right, Instance):
-            return False
-
-        left_name = left.type.fullname
-        right_name = right.type.fullname
-
-        # Check if this pair is in our list of known unsafe subtyping relationships
-        # Check both directions since we want to catch comparisons either way
-        for subclass, superclass in UNSAFE_SUBTYPING_PAIRS:
-            if ((left_name == subclass and right_name == superclass)
-                    or (left_name == superclass and right_name == subclass)):
-                return True
-
-        return False
-
     def check_method_call_by_name(
         self,
         method: str,

mypy/messages.py

@@ -1655,18 +1655,6 @@ def dangerous_comparison(self, left: Type, right: Type, kind: str, ctx: Context)
             code=codes.COMPARISON_OVERLAP,
         )
 
-    def unsafe_subtype_comparison(
-        self, left: Type, right: Type, operator: str, ctx: Context
-    ) -> None:
-        """Report a comparison between types with an unsafe subtyping relationship.
-
-        This warns about comparisons where the types have a nominal subclass relationship
-        but comparing them can cause runtime errors (e.g., datetime vs date).
-        """
-        left_typ, right_typ = format_type_distinctly(left, right, options=self.options)
-        message = f"Unsafe comparison between {left_typ} and {right_typ}; runtime comparison may raise TypeError"
-        self.fail(message, ctx, code=codes.UNSAFE_SUBTYPE)
-
     def overload_inconsistently_applies_decorator(self, decorator: str, context: Context) -> None:
         self.fail(
             f'Overload does not consistently use the "@{decorator}" '

test-data/unit/check-unsafe-subtype.test

@@ -11,10 +11,10 @@ if dt < d:  # E: Unsupported operand types for < ("datetime" and "date")
 if d > dt:  # E: Unsupported operand types for < ("datetime" and "date")
     pass
 
-if dt == d:  # E: Unsafe comparison between "datetime" and "date"; runtime comparison may raise TypeError
+if dt == d:
     pass
 
-if dt != d:  # E: Unsafe comparison between "datetime" and "date"; runtime comparison may raise TypeError
+if dt != d:
     pass
 
 if dt <= d:  # E: Unsupported operand types for <= ("datetime" and "date")