Class IterationDependentErrors

mypy/errors.py:305–388

An `IterationDependentErrors` instance serves to collect the `unreachable`, `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.

class IterationDependentErrors:
    """An `IterationDependentErrors` instance serves to collect the `unreachable`,
    `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,
    # end_line, end_column.
    uselessness_errors: list[set[tuple[ErrorCode, str, int, int, int, int]]]

    # One set of unreachable line numbers per iteration step.  Not only the lines where
    # the error report occurs but really all unreachable lines.
    unreachable_lines: list[set[int]]

    # One list of revealed types for each `reveal_type` statement.  Each created list
    # can grow during the iteration.  Meaning of the tuple items: line, column,
    # 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]]:
        """Report only those `unreachable`, `redundant-expr`, and `redundant-casts`
        errors that could not be ruled out in any iteration step."""

        persistent_uselessness_errors = set()
        for candidate in set(chain(*self.uselessness_errors)):
            if all(
                (candidate in errors) or (candidate[2] in lines)
                for errors, lines in zip(self.uselessness_errors, self.unreachable_lines)
            ):
                persistent_uselessness_errors.add(candidate)
        for error_info in persistent_uselessness_errors:
            context = Context(line=error_info[2], column=error_info[3])
            context.end_line = error_info[4]
            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)
            ):