Fix --strict-equality for iteratively visited code

mypy/errors.py

@@ -229,11 +229,42 @@ def filtered_errors(self) -> list[ErrorInfo]:
         return self._filtered
 
 
+class NonOverlapErrorInfo:
+    line: int
+    column: int
+    end_line: int | None
+    end_column: int | None
+    kind: str
+
+    def __init__(
+        self, *, line: int, column: int, end_line: int | None, end_column: int | None, kind: str
+    ) -> None:
+        self.line = line
+        self.column = column
+        self.end_line = end_line
+        self.end_column = end_column
+        self.kind = kind
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, NonOverlapErrorInfo):
+            return (
+                self.line == other.line
+                and self.column == other.column
+                and self.end_line == other.end_line
+                and self.end_column == other.end_column
+                and self.kind == other.kind
+            )
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self.line, self.column, self.end_line, self.end_column, self.kind))
+
+
 class IterationDependentErrors:
     """An `IterationDependentErrors` instance serves to collect the `unreachable`,
-    `redundant-expr`, and `redundant-casts` errors, as well as the revealed types,
-    handled by the individual `IterationErrorWatcher` instances sequentially applied to
-    the same code section."""
+    `redundant-expr`, and `redundant-casts` errors, as well as the revealed types and
+    non-overlapping types, handled by the individual `IterationErrorWatcher` instances
+    sequentially applied to the same code section."""
 
     # One set of `unreachable`, `redundant-expr`, and `redundant-casts` errors per
     # iteration step.  Meaning of the tuple items: ErrorCode, message, line, column,
@@ -249,9 +280,13 @@ class IterationDependentErrors:
     # end_line, end_column:
     revealed_types: dict[tuple[int, int, int | None, int | None], list[Type]]
 
+    # One dictionary of non-overlapping types per iteration step:
+    nonoverlapping_types: list[dict[NonOverlapErrorInfo, tuple[Type, Type]]]
+
     def __init__(self) -> None:
         self.uselessness_errors = []
         self.unreachable_lines = []
+        self.nonoverlapping_types = []
         self.revealed_types = defaultdict(list)
 
     def yield_uselessness_error_infos(self) -> Iterator[tuple[str, Context, ErrorCode]]:
@@ -271,6 +306,36 @@ def yield_uselessness_error_infos(self) -> Iterator[tuple[str, Context, ErrorCod
             context.end_column = error_info[5]
             yield error_info[1], context, error_info[0]
 
+    def yield_nonoverlapping_types(
+        self,
+    ) -> Iterator[tuple[tuple[list[Type], list[Type]], str, Context]]:
+        """Report expressions where non-overlapping types were detected for all iterations
+        were the expression was reachable."""
+
+        selected = set()
+        for candidate in set(chain.from_iterable(self.nonoverlapping_types)):
+            if all(
+                (candidate in nonoverlap) or (candidate.line in lines)
+                for nonoverlap, lines in zip(self.nonoverlapping_types, self.unreachable_lines)
+            ):
+                selected.add(candidate)
+
+        persistent_nonoverlaps: dict[NonOverlapErrorInfo, tuple[list[Type], list[Type]]] = (
+            defaultdict(lambda: ([], []))
+        )
+        for nonoverlaps in self.nonoverlapping_types:
+            for candidate, (left, right) in nonoverlaps.items():
+                if candidate in selected:
+                    types = persistent_nonoverlaps[candidate]
+                    types[0].append(left)
+                    types[1].append(right)
+
+        for error_info, types in persistent_nonoverlaps.items():
+            context = Context(line=error_info.line, column=error_info.column)
+            context.end_line = error_info.end_line
+            context.end_column = error_info.end_column
+            yield (types[0], types[1]), error_info.kind, context
+
     def yield_revealed_type_infos(self) -> Iterator[tuple[list[Type], Context]]:
         """Yield all types revealed in at least one iteration step."""
 
@@ -283,8 +348,9 @@ def yield_revealed_type_infos(self) -> Iterator[tuple[list[Type], Context]]:
 
 class IterationErrorWatcher(ErrorWatcher):
     """Error watcher that filters and separately collects `unreachable` errors,
-    `redundant-expr` and `redundant-casts` errors, and revealed types when analysing
-    code sections iteratively to help avoid making too-hasty reports."""
+    `redundant-expr` and `redundant-casts` errors, and revealed types and
+    non-overlapping types when analysing code sections iteratively to help avoid
+    making too-hasty reports."""
 
     iteration_dependent_errors: IterationDependentErrors
 
@@ -305,6 +371,7 @@ def __init__(
         )
         self.iteration_dependent_errors = iteration_dependent_errors
         iteration_dependent_errors.uselessness_errors.append(set())
+        iteration_dependent_errors.nonoverlapping_types.append({})
         iteration_dependent_errors.unreachable_lines.append(set())
 
     def on_error(self, file: str, info: ErrorInfo) -> bool:

mypy/messages.py

@@ -29,6 +29,7 @@
     ErrorWatcher,
     IterationDependentErrors,
     IterationErrorWatcher,
+    NonOverlapErrorInfo,
 )
 from mypy.nodes import (
     ARG_NAMED,
@@ -1624,6 +1625,26 @@ def incompatible_typevar_value(
         )
 
     def dangerous_comparison(self, left: Type, right: Type, kind: str, ctx: Context) -> None:
+        # In loops (and similar cases), the same expression might be analysed multiple
+        # times and thereby confronted with different types.  We only want to raise a
+        # `comparison-overlap` error if it occurs in all cases and therefore collect the
+        # respective types of the current iteration here so that we can report the error
+        # later if it is persistent over all iteration steps:
+        for watcher in self.errors.get_watchers():
+            if watcher._filter:
+                break
+            if isinstance(watcher, IterationErrorWatcher):
+                watcher.iteration_dependent_errors.nonoverlapping_types[-1][
+                    NonOverlapErrorInfo(
+                        line=ctx.line,
+                        column=ctx.column,
+                        end_line=ctx.end_line,
+                        end_column=ctx.end_column,
+                        kind=kind,
+                    )
+                ] = (left, right)
+                return
+
         left_str = "element" if kind == "container" else "left operand"
         right_str = "container item" if kind == "container" else "right operand"
         message = "Non-overlapping {} check ({} type: {}, {} type: {})"
@@ -2510,6 +2531,13 @@ def match_statement_inexhaustive_match(self, typ: Type, context: Context) -> Non
     def iteration_dependent_errors(self, iter_errors: IterationDependentErrors) -> None:
         for error_info in iter_errors.yield_uselessness_error_infos():
             self.fail(*error_info[:2], code=error_info[2])
+        for nonoverlaps, kind, context in iter_errors.yield_nonoverlapping_types():
+            self.dangerous_comparison(
+                mypy.typeops.make_simplified_union(nonoverlaps[0]),
+                mypy.typeops.make_simplified_union(nonoverlaps[1]),
+                kind,
+                context,
+            )
         for types, context in iter_errors.yield_revealed_type_infos():
             self.reveal_type(mypy.typeops.make_simplified_union(types), context)
 

test-data/unit/check-narrowing.test

@@ -2446,6 +2446,41 @@ while x is not None and b():
     x = f()
 [builtins fixtures/primitives.pyi]
 
+[case testAvoidFalseNonOverlappingEqualityCheckInLoop1]
+# flags: --allow-redefinition-new --local-partial-types --strict-equality
+
+x = 1
+while True:
+    if x == str():
+        break
+    x = str()
+    if x == int():  # E: Non-overlapping equality check (left operand type: "str", right operand type: "int")
+        break
+[builtins fixtures/primitives.pyi]
+
+[case testAvoidFalseNonOverlappingEqualityCheckInLoop2]
+# flags: --allow-redefinition-new --local-partial-types --strict-equality
+
+class A: ...
+class B: ...
+class C: ...
+
+x = A()
+while True:
+    if x == C():  # E: Non-overlapping equality check (left operand type: "A | B", right operand type: "C")
+        break
+    x = B()
+[builtins fixtures/primitives.pyi]
+
+[case testAvoidFalseNonOverlappingEqualityCheckInLoop3]
+# flags: --strict-equality
+
+for y in [1.0]:
+    if y is not None or y != "None":
+        ...
+
+[builtins fixtures/primitives.pyi]
+
 [case testNarrowPromotionsInsideUnions1]
 
 from typing import Union