jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy/errors.py

@@ -1,1280 +0,0 @@
-from __future__ import annotations
-
-import os.path
-import sys
-import traceback
-from collections import defaultdict
-from typing import Callable, Final, Iterable, NoReturn, Optional, TextIO, Tuple, TypeVar
-from typing_extensions import Literal, TypeAlias as _TypeAlias
-
-from mypy import errorcodes as codes
-from mypy.errorcodes import IMPORT, IMPORT_NOT_FOUND, IMPORT_UNTYPED, ErrorCode, mypy_error_codes
-from mypy.message_registry import ErrorMessage
-from mypy.options import Options
-from mypy.scope import Scope
-from mypy.util import DEFAULT_SOURCE_OFFSET, is_typeshed_file
-from mypy.version import __version__ as mypy_version
-
-T = TypeVar("T")
-
-# Show error codes for some note-level messages (these usually appear alone
-# and not as a comment for a previous error-level message).
-SHOW_NOTE_CODES: Final = {codes.ANNOTATION_UNCHECKED}
-
-# Do not add notes with links to error code docs to errors with these codes.
-# We can tweak this set as we get more experience about what is helpful and what is not.
-HIDE_LINK_CODES: Final = {
-    # This is a generic error code, so it has no useful docs
-    codes.MISC,
-    # These are trivial and have some custom notes (e.g. for list being invariant)
-    codes.ASSIGNMENT,
-    codes.ARG_TYPE,
-    codes.RETURN_VALUE,
-    # Undefined name/attribute errors are self-explanatory
-    codes.ATTR_DEFINED,
-    codes.NAME_DEFINED,
-    # Overrides have a custom link to docs
-    codes.OVERRIDE,
-}
-
-allowed_duplicates: Final = ["@overload", "Got:", "Expected:"]
-
-BASE_RTD_URL: Final = "https://mypy.rtfd.io/en/stable/_refs.html#code"
-
-# Keep track of the original error code when the error code of a message is changed.
-# This is used to give notes about out-of-date "type: ignore" comments.
-original_error_codes: Final = {codes.LITERAL_REQ: codes.MISC, codes.TYPE_ABSTRACT: codes.MISC}
-
-
-class ErrorInfo:
-    """Representation of a single error message."""
-
-    # Description of a sequence of imports that refer to the source file
-    # related to this error. Each item is a (path, line number) tuple.
-    import_ctx: list[tuple[str, int]]
-
-    # The path to source file that was the source of this error.
-    file = ""
-
-    # The fully-qualified id of the source module for this error.
-    module: str | None = None
-
-    # The name of the type in which this error is located at.
-    type: str | None = ""  # Unqualified, may be None
-
-    # The name of the function or member in which this error is located at.
-    function_or_member: str | None = ""  # Unqualified, may be None
-
-    # The line number related to this error within file.
-    line = 0  # -1 if unknown
-
-    # The column number related to this error with file.
-    column = 0  # -1 if unknown
-
-    # The end line number related to this error within file.
-    end_line = 0  # -1 if unknown
-
-    # The end column number related to this error with file.
-    end_column = 0  # -1 if unknown
-
-    # Either 'error' or 'note'
-    severity = ""
-
-    # The error message.
-    message = ""
-
-    # The error code.
-    code: ErrorCode | None = None
-
-    # If True, we should halt build after the file that generated this error.
-    blocker = False
-
-    # Only report this particular messages once per program.
-    only_once = False
-
-    # Do not remove duplicate copies of this message (ignored if only_once is True).
-    allow_dups = False
-
-    # Actual origin of the error message as tuple (path, line number, end line number)
-    # If end line number is unknown, use line number.
-    origin: tuple[str, Iterable[int]]
-
-    # Fine-grained incremental target where this was reported
-    target: str | None = None
-
-    # If True, don't show this message in output, but still record the error (needed
-    # by mypy daemon)
-    hidden = False
-
-    def __init__(
-        self,
-        import_ctx: list[tuple[str, int]],
-        *,
-        file: str,
-        module: str | None,
-        typ: str | None,
-        function_or_member: str | None,
-        line: int,
-        column: int,
-        end_line: int,
-        end_column: int,
-        severity: str,
-        message: str,
-        code: ErrorCode | None,
-        blocker: bool,
-        only_once: bool,
-        allow_dups: bool,
-        origin: tuple[str, Iterable[int]] | None = None,
-        target: str | None = None,
-        priority: int = 0,
-    ) -> None:
-        self.import_ctx = import_ctx
-        self.file = file
-        self.module = module
-        self.type = typ
-        self.function_or_member = function_or_member
-        self.line = line
-        self.column = column
-        self.end_line = end_line
-        self.end_column = end_column
-        self.severity = severity
-        self.message = message
-        self.code = code
-        self.blocker = blocker
-        self.only_once = only_once
-        self.allow_dups = allow_dups
-        self.origin = origin or (file, [line])
-        self.target = target
-        self.priority = priority
-
-
-# Type used internally to represent errors:
-#   (path, line, column, end_line, end_column, severity, message, allow_dups, code)
-ErrorTuple: _TypeAlias = Tuple[
-    Optional[str], int, int, int, int, str, str, bool, Optional[ErrorCode]
-]
-
-
-class ErrorWatcher:
-    """Context manager that can be used to keep track of new errors recorded
-    around a given operation.
-
-    Errors maintain a stack of such watchers. The handler is called starting
-    at the top of the stack, and is propagated down the stack unless filtered
-    out by one of the ErrorWatcher instances.
-    """
-
-    def __init__(
-        self,
-        errors: Errors,
-        *,
-        filter_errors: bool | Callable[[str, ErrorInfo], bool] = False,
-        save_filtered_errors: bool = False,
-    ) -> None:
-        self.errors = errors
-        self._has_new_errors = False
-        self._filter = filter_errors
-        self._filtered: list[ErrorInfo] | None = [] if save_filtered_errors else None
-
-    def __enter__(self) -> ErrorWatcher:
-        self.errors._watchers.append(self)
-        return self
-
-    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> Literal[False]:
-        last = self.errors._watchers.pop()
-        assert last == self
-        return False
-
-    def on_error(self, file: str, info: ErrorInfo) -> bool:
-        """Handler called when a new error is recorded.
-
-        The default implementation just sets the has_new_errors flag
-
-        Return True to filter out the error, preventing it from being seen by other
-        ErrorWatcher further down the stack and from being recorded by Errors
-        """
-        self._has_new_errors = True
-        if isinstance(self._filter, bool):
-            should_filter = self._filter
-        elif callable(self._filter):
-            should_filter = self._filter(file, info)
-        else:
-            raise AssertionError(f"invalid error filter: {type(self._filter)}")
-        if should_filter and self._filtered is not None:
-            self._filtered.append(info)
-
-        return should_filter
-
-    def has_new_errors(self) -> bool:
-        return self._has_new_errors
-
-    def filtered_errors(self) -> list[ErrorInfo]:
-        assert self._filtered is not None
-        return self._filtered
-
-
-class Errors:
-    """Container for compile errors.
-
-    This class generates and keeps tracks of compile errors and the
-    current error context (nested imports).
-    """
-
-    # Map from files to generated error messages. Is an OrderedDict so
-    # that it can be used to order messages based on the order the
-    # files were processed.
-    error_info_map: dict[str, list[ErrorInfo]]
-
-    # optimization for legacy codebases with many files with errors
-    has_blockers: set[str]
-
-    # Files that we have reported the errors for
-    flushed_files: set[str]
-
-    # Current error context: nested import context/stack, as a list of (path, line) pairs.
-    import_ctx: list[tuple[str, int]]
-
-    # Path name prefix that is removed from all paths, if set.
-    ignore_prefix: str | None = None
-
-    # Path to current file.
-    file: str = ""
-
-    # Ignore some errors on these lines of each file
-    # (path -> line -> error-codes)
-    ignored_lines: dict[str, dict[int, list[str]]]
-
-    # Lines that were skipped during semantic analysis e.g. due to ALWAYS_FALSE, MYPY_FALSE,
-    # or platform/version checks. Those lines would not be type-checked.
-    skipped_lines: dict[str, set[int]]
-
-    # Lines on which an error was actually ignored.
-    used_ignored_lines: dict[str, dict[int, list[str]]]
-
-    # Files where all errors should be ignored.
-    ignored_files: set[str]
-
-    # Collection of reported only_once messages.
-    only_once_messages: set[str]
-
-    # Set to True to show "In function "foo":" messages.
-    show_error_context: bool = False
-
-    # Set to True to show column numbers in error messages.
-    show_column_numbers: bool = False
-
-    # Set to True to show end line and end column in error messages.
-    # Ths implies `show_column_numbers`.
-    show_error_end: bool = False
-
-    # Set to True to show absolute file paths in error messages.
-    show_absolute_path: bool = False
-
-    # State for keeping track of the current fine-grained incremental mode target.
-    # (See mypy.server.update for more about targets.)
-    # Current module id.
-    target_module: str | None = None
-    scope: Scope | None = None
-
-    # Have we seen an import-related error so far? If yes, we filter out other messages
-    # in some cases to avoid reporting huge numbers of errors.
-    seen_import_error = False
-
-    _watchers: list[ErrorWatcher] = []
-
-    def __init__(
-        self,
-        options: Options,
-        *,
-        read_source: Callable[[str], list[str] | None] | None = None,
-        hide_error_codes: bool | None = None,
-    ) -> None:
-        self.options = options
-        self.hide_error_codes = (
-            hide_error_codes if hide_error_codes is not None else options.hide_error_codes
-        )
-        # We use fscache to read source code when showing snippets.
-        self.read_source = read_source
-        self.initialize()
-
-    def initialize(self) -> None:
-        self.error_info_map = {}
-        self.flushed_files = set()
-        self.import_ctx = []
-        self.function_or_member = [None]
-        self.ignored_lines = {}
-        self.skipped_lines = {}
-        self.used_ignored_lines = defaultdict(lambda: defaultdict(list))
-        self.ignored_files = set()
-        self.only_once_messages = set()
-        self.has_blockers = set()
-        self.scope = None
-        self.target_module = None
-        self.seen_import_error = False
-
-    def reset(self) -> None:
-        self.initialize()
-
-    def set_ignore_prefix(self, prefix: str) -> None:
-        """Set path prefix that will be removed from all paths."""
-        prefix = os.path.normpath(prefix)
-        # Add separator to the end, if not given.
-        if os.path.basename(prefix) != "":
-            prefix += os.sep
-        self.ignore_prefix = prefix
-
-    def simplify_path(self, file: str) -> str:
-        if self.options.show_absolute_path:
-            return os.path.abspath(file)
-        else:
-            file = os.path.normpath(file)
-            return remove_path_prefix(file, self.ignore_prefix)
-
-    def set_file(
-        self, file: str, module: str | None, options: Options, scope: Scope | None = None
-    ) -> None:
-        """Set the path and module id of the current file."""
-        # The path will be simplified later, in render_messages. That way
-        #  * 'file' is always a key that uniquely identifies a source file
-        #    that mypy read (simplified paths might not be unique); and
-        #  * we only have to simplify in one place, while still supporting
-        #    reporting errors for files other than the one currently being
-        #    processed.
-        self.file = file
-        self.target_module = module
-        self.scope = scope
-        self.options = options
-
-    def set_file_ignored_lines(
-        self, file: str, ignored_lines: dict[int, list[str]], ignore_all: bool = False
-    ) -> None:
-        self.ignored_lines[file] = ignored_lines
-        if ignore_all:
-            self.ignored_files.add(file)
-
-    def set_skipped_lines(self, file: str, skipped_lines: set[int]) -> None:
-        self.skipped_lines[file] = skipped_lines
-
-    def current_target(self) -> str | None:
-        """Retrieves the current target from the associated scope.
-
-        If there is no associated scope, use the target module."""
-        if self.scope is not None:
-            return self.scope.current_target()
-        return self.target_module
-
-    def current_module(self) -> str | None:
-        return self.target_module
-
-    def import_context(self) -> list[tuple[str, int]]:
-        """Return a copy of the import context."""
-        return self.import_ctx.copy()
-
-    def set_import_context(self, ctx: list[tuple[str, int]]) -> None:
-        """Replace the entire import context with a new value."""
-        self.import_ctx = ctx.copy()
-
-    def report(
-        self,
-        line: int,
-        column: int | None,
-        message: str,
-        code: ErrorCode | None = None,
-        *,
-        blocker: bool = False,
-        severity: str = "error",
-        file: str | None = None,
-        only_once: bool = False,
-        allow_dups: bool = False,
-        origin_span: Iterable[int] | None = None,
-        offset: int = 0,
-        end_line: int | None = None,
-        end_column: int | None = None,
-    ) -> None:
-        """Report message at the given line using the current error context.
-
-        Args:
-            line: line number of error
-            column: column number of error
-            message: message to report
-            code: error code (defaults to 'misc'; not shown for notes)
-            blocker: if True, don't continue analysis after this error
-            severity: 'error' or 'note'
-            file: if non-None, override current file as context
-            only_once: if True, only report this exact message once per build
-            allow_dups: if True, allow duplicate copies of this message (ignored if only_once)
-            origin_span: if non-None, override current context as origin
-                         (type: ignores have effect here)
-            end_line: if non-None, override current context as end
-        """
-        if self.scope:
-            type = self.scope.current_type_name()
-            if self.scope.ignored > 0:
-                type = None  # Omit type context if nested function
-            function = self.scope.current_function_name()
-        else:
-            type = None
-            function = None
-
-        if column is None:
-            column = -1
-        if end_column is None:
-            if column == -1:
-                end_column = -1
-            else:
-                end_column = column + 1
-
-        if file is None:
-            file = self.file
-        if offset:
-            message = " " * offset + message
-
-        if origin_span is None:
-            origin_span = [line]
-
-        if end_line is None:
-            end_line = line
-
-        code = code or (codes.MISC if not blocker else None)
-
-        info = ErrorInfo(
-            import_ctx=self.import_context(),
-            file=file,
-            module=self.current_module(),
-            typ=type,
-            function_or_member=function,
-            line=line,
-            column=column,
-            end_line=end_line,
-            end_column=end_column,
-            severity=severity,
-            message=message,
-            code=code,
-            blocker=blocker,
-            only_once=only_once,
-            allow_dups=allow_dups,
-            origin=(self.file, origin_span),
-            target=self.current_target(),
-        )
-        self.add_error_info(info)
-
-    def _add_error_info(self, file: str, info: ErrorInfo) -> None:
-        assert file not in self.flushed_files
-        # process the stack of ErrorWatchers before modifying any internal state
-        # in case we need to filter out the error entirely
-        if self._filter_error(file, info):
-            return
-        if file not in self.error_info_map:
-            self.error_info_map[file] = []
-        self.error_info_map[file].append(info)
-        if info.blocker:
-            self.has_blockers.add(file)
-        if info.code in (IMPORT, IMPORT_UNTYPED, IMPORT_NOT_FOUND):
-            self.seen_import_error = True
-
-    def _filter_error(self, file: str, info: ErrorInfo) -> bool:
-        """
-        process ErrorWatcher stack from top to bottom,
-        stopping early if error needs to be filtered out
-        """
-        i = len(self._watchers)
-        while i > 0:
-            i -= 1
-            w = self._watchers[i]
-            if w.on_error(file, info):
-                return True
-        return False
-
-    def add_error_info(self, info: ErrorInfo) -> None:
-        file, lines = info.origin
-        # process the stack of ErrorWatchers before modifying any internal state
-        # in case we need to filter out the error entirely
-        # NB: we need to do this both here and in _add_error_info, otherwise we
-        # might incorrectly update the sets of ignored or only_once messages
-        if self._filter_error(file, info):
-            return
-        if not info.blocker:  # Blockers cannot be ignored
-            if file in self.ignored_lines:
-                # Check each line in this context for "type: ignore" comments.
-                # line == end_line for most nodes, so we only loop once.
-                for scope_line in lines:
-                    if self.is_ignored_error(scope_line, info, self.ignored_lines[file]):
-                        # Annotation requests us to ignore all errors on this line.
-                        self.used_ignored_lines[file][scope_line].append(
-                            (info.code or codes.MISC).code
-                        )
-                        return
-            if file in self.ignored_files:
-                return
-        if info.only_once:
-            if info.message in self.only_once_messages:
-                return
-            self.only_once_messages.add(info.message)
-        if (
-            self.seen_import_error
-            and info.code not in (IMPORT, IMPORT_UNTYPED, IMPORT_NOT_FOUND)
-            and self.has_many_errors()
-        ):
-            # Missing stubs can easily cause thousands of errors about
-            # Any types, especially when upgrading to mypy 0.900,
-            # which no longer bundles third-party library stubs. Avoid
-            # showing too many errors to make it easier to see
-            # import-related errors.
-            info.hidden = True
-            self.report_hidden_errors(info)
-        self._add_error_info(file, info)
-        ignored_codes = self.ignored_lines.get(file, {}).get(info.line, [])
-        if ignored_codes and info.code:
-            # Something is ignored on the line, but not this error, so maybe the error
-            # code is incorrect.
-            msg = f'Error code "{info.code.code}" not covered by "type: ignore" comment'
-            if info.code in original_error_codes:
-                # If there seems to be a "type: ignore" with a stale error
-                # code, report a more specific note.
-                old_code = original_error_codes[info.code].code
-                if old_code in ignored_codes:
-                    msg = (
-                        f'Error code changed to {info.code.code}; "type: ignore" comment '
-                        + "may be out of date"
-                    )
-            note = ErrorInfo(
-                import_ctx=info.import_ctx,
-                file=info.file,
-                module=info.module,
-                typ=info.type,
-                function_or_member=info.function_or_member,
-                line=info.line,
-                column=info.column,
-                end_line=info.end_line,
-                end_column=info.end_column,
-                severity="note",
-                message=msg,
-                code=None,
-                blocker=False,
-                only_once=False,
-                allow_dups=False,
-            )
-            self._add_error_info(file, note)
-        if (
-            self.options.show_error_code_links
-            and not self.options.hide_error_codes
-            and info.code is not None
-            and info.code not in HIDE_LINK_CODES
-            and info.code.code in mypy_error_codes
-        ):
-            message = f"See {BASE_RTD_URL}-{info.code.code} for more info"
-            if message in self.only_once_messages:
-                return
-            self.only_once_messages.add(message)
-            info = ErrorInfo(
-                import_ctx=info.import_ctx,
-                file=info.file,
-                module=info.module,
-                typ=info.type,
-                function_or_member=info.function_or_member,
-                line=info.line,
-                column=info.column,
-                end_line=info.end_line,
-                end_column=info.end_column,
-                severity="note",
-                message=message,
-                code=info.code,
-                blocker=False,
-                only_once=True,
-                allow_dups=False,
-                priority=20,
-            )
-            self._add_error_info(file, info)
-
-    def has_many_errors(self) -> bool:
-        if self.options.many_errors_threshold < 0:
-            return False
-        if len(self.error_info_map) >= self.options.many_errors_threshold:
-            return True
-        if (
-            sum(len(errors) for errors in self.error_info_map.values())
-            >= self.options.many_errors_threshold
-        ):
-            return True
-        return False
-
-    def report_hidden_errors(self, info: ErrorInfo) -> None:
-        message = (
-            "(Skipping most remaining errors due to unresolved imports or missing stubs; "
-            + "fix these first)"
-        )
-        if message in self.only_once_messages:
-            return
-        self.only_once_messages.add(message)
-        new_info = ErrorInfo(
-            import_ctx=info.import_ctx,
-            file=info.file,
-            module=info.module,
-            typ=None,
-            function_or_member=None,
-            line=info.line,
-            column=info.column,
-            end_line=info.end_line,
-            end_column=info.end_column,
-            severity="note",
-            message=message,
-            code=None,
-            blocker=False,
-            only_once=True,
-            allow_dups=False,
-            origin=info.origin,
-            target=info.target,
-        )
-        self._add_error_info(info.origin[0], new_info)
-
-    def is_ignored_error(self, line: int, info: ErrorInfo, ignores: dict[int, list[str]]) -> bool:
-        if info.blocker:
-            # Blocking errors can never be ignored
-            return False
-        if info.code and not self.is_error_code_enabled(info.code):
-            return True
-        if line not in ignores:
-            return False
-        if not ignores[line]:
-            # Empty list means that we ignore all errors
-            return True
-        if info.code and self.is_error_code_enabled(info.code):
-            return (
-                info.code.code in ignores[line]
-                or info.code.sub_code_of is not None
-                and info.code.sub_code_of.code in ignores[line]
-            )
-        return False
-
-    def is_error_code_enabled(self, error_code: ErrorCode) -> bool:
-        if self.options:
-            current_mod_disabled = self.options.disabled_error_codes
-            current_mod_enabled = self.options.enabled_error_codes
-        else:
-            current_mod_disabled = set()
-            current_mod_enabled = set()
-
-        if error_code in current_mod_disabled:
-            return False
-        elif error_code in current_mod_enabled:
-            return True
-        elif error_code.sub_code_of is not None and error_code.sub_code_of in current_mod_disabled:
-            return False
-        else:
-            return error_code.default_enabled
-
-    def clear_errors_in_targets(self, path: str, targets: set[str]) -> None:
-        """Remove errors in specific fine-grained targets within a file."""
-        if path in self.error_info_map:
-            new_errors = []
-            has_blocker = False
-            for info in self.error_info_map[path]:
-                if info.target not in targets:
-                    new_errors.append(info)
-                    has_blocker |= info.blocker
-                elif info.only_once:
-                    self.only_once_messages.remove(info.message)
-            self.error_info_map[path] = new_errors
-            if not has_blocker and path in self.has_blockers:
-                self.has_blockers.remove(path)
-
-    def generate_unused_ignore_errors(self, file: str) -> None:
-        if (
-            is_typeshed_file(self.options.abs_custom_typeshed_dir if self.options else None, file)
-            or file in self.ignored_files
-        ):
-            return
-        ignored_lines = self.ignored_lines[file]
-        used_ignored_lines = self.used_ignored_lines[file]
-        for line, ignored_codes in ignored_lines.items():
-            if line in self.skipped_lines[file]:
-                continue
-            if codes.UNUSED_IGNORE.code in ignored_codes:
-                continue
-            used_ignored_codes = used_ignored_lines[line]
-            unused_ignored_codes = set(ignored_codes) - set(used_ignored_codes)
-            # `ignore` is used
-            if not ignored_codes and used_ignored_codes:
-                continue
-            # All codes appearing in `ignore[...]` are used
-            if ignored_codes and not unused_ignored_codes:
-                continue
-            # Display detail only when `ignore[...]` specifies more than one error code
-            unused_codes_message = ""
-            if len(ignored_codes) > 1 and unused_ignored_codes:
-                unused_codes_message = f"[{', '.join(sorted(unused_ignored_codes))}]"
-            message = f'Unused "type: ignore{unused_codes_message}" comment'
-            for unused in unused_ignored_codes:
-                narrower = set(used_ignored_codes) & codes.sub_code_map[unused]
-                if narrower:
-                    message += f", use narrower [{', '.join(narrower)}] instead of [{unused}] code"
-            # Don't use report since add_error_info will ignore the error!
-            info = ErrorInfo(
-                import_ctx=self.import_context(),
-                file=file,
-                module=self.current_module(),
-                typ=None,
-                function_or_member=None,
-                line=line,
-                column=-1,
-                end_line=line,
-                end_column=-1,
-                severity="error",
-                message=message,
-                code=codes.UNUSED_IGNORE,
-                blocker=False,
-                only_once=False,
-                allow_dups=False,
-            )
-            self._add_error_info(file, info)
-
-    def generate_ignore_without_code_errors(
-        self, file: str, is_warning_unused_ignores: bool
-    ) -> None:
-        if (
-            is_typeshed_file(self.options.abs_custom_typeshed_dir if self.options else None, file)
-            or file in self.ignored_files
-        ):
-            return
-
-        used_ignored_lines = self.used_ignored_lines[file]
-
-        # If the whole file is ignored, ignore it.
-        if used_ignored_lines:
-            _, used_codes = min(used_ignored_lines.items())
-            if codes.FILE.code in used_codes:
-                return
-
-        for line, ignored_codes in self.ignored_lines[file].items():
-            if ignored_codes:
-                continue
-
-            # If the ignore is itself unused and that would be warned about, let
-            # that error stand alone
-            if is_warning_unused_ignores and not used_ignored_lines[line]:
-                continue
-
-            codes_hint = ""
-            ignored_codes = sorted(set(used_ignored_lines[line]))
-            if ignored_codes:
-                codes_hint = f' (consider "type: ignore[{", ".join(ignored_codes)}]" instead)'
-
-            message = f'"type: ignore" comment without error code{codes_hint}'
-            # Don't use report since add_error_info will ignore the error!
-            info = ErrorInfo(
-                import_ctx=self.import_context(),
-                file=file,
-                module=self.current_module(),
-                typ=None,
-                function_or_member=None,
-                line=line,
-                column=-1,
-                end_line=line,
-                end_column=-1,
-                severity="error",
-                message=message,
-                code=codes.IGNORE_WITHOUT_CODE,
-                blocker=False,
-                only_once=False,
-                allow_dups=False,
-            )
-            self._add_error_info(file, info)
-
-    def num_messages(self) -> int:
-        """Return the number of generated messages."""
-        return sum(len(x) for x in self.error_info_map.values())
-
-    def is_errors(self) -> bool:
-        """Are there any generated messages?"""
-        return bool(self.error_info_map)
-
-    def is_blockers(self) -> bool:
-        """Are the any errors that are blockers?"""
-        return bool(self.has_blockers)
-
-    def blocker_module(self) -> str | None:
-        """Return the module with a blocking error, or None if not possible."""
-        for path in self.has_blockers:
-            for err in self.error_info_map[path]:
-                if err.blocker:
-                    return err.module
-        return None
-
-    def is_errors_for_file(self, file: str) -> bool:
-        """Are there any errors for the given file?"""
-        return file in self.error_info_map
-
-    def prefer_simple_messages(self) -> bool:
-        """Should we generate simple/fast error messages?
-
-        Return True if errors are not shown to user, i.e. errors are ignored
-        or they are collected for internal use only.
-
-        If True, we should prefer to generate a simple message quickly.
-        All normal errors should still be reported.
-        """
-        if self.file in self.ignored_files:
-            # Errors ignored, so no point generating fancy messages
-            return True
-        for _watcher in self._watchers:
-            if _watcher._filter is True and _watcher._filtered is None:
-                # Errors are filtered
-                return True
-        return False
-
-    def raise_error(self, use_stdout: bool = True) -> NoReturn:
-        """Raise a CompileError with the generated messages.
-
-        Render the messages suitable for displaying.
-        """
-        # self.new_messages() will format all messages that haven't already
-        # been returned from a file_messages() call.
-        raise CompileError(
-            self.new_messages(), use_stdout=use_stdout, module_with_blocker=self.blocker_module()
-        )
-
-    def format_messages(
-        self, error_info: list[ErrorInfo], source_lines: list[str] | None
-    ) -> list[str]:
-        """Return a string list that represents the error messages.
-
-        Use a form suitable for displaying to the user. If self.pretty
-        is True also append a relevant trimmed source code line (only for
-        severity 'error').
-        """
-        a: list[str] = []
-        error_info = [info for info in error_info if not info.hidden]
-        errors = self.render_messages(self.sort_messages(error_info))
-        errors = self.remove_duplicates(errors)
-        for (
-            file,
-            line,
-            column,
-            end_line,
-            end_column,
-            severity,
-            message,
-            allow_dups,
-            code,
-        ) in errors:
-            s = ""
-            if file is not None:
-                if self.options.show_column_numbers and line >= 0 and column >= 0:
-                    srcloc = f"{file}:{line}:{1 + column}"
-                    if self.options.show_error_end and end_line >= 0 and end_column >= 0:
-                        srcloc += f":{end_line}:{end_column}"
-                elif line >= 0:
-                    srcloc = f"{file}:{line}"
-                else:
-                    srcloc = file
-                s = f"{srcloc}: {severity}: {message}"
-            else:
-                s = message
-            if (
-                not self.hide_error_codes
-                and code
-                and (severity != "note" or code in SHOW_NOTE_CODES)
-            ):
-                # If note has an error code, it is related to a previous error. Avoid
-                # displaying duplicate error codes.
-                s = f"{s}  [{code.code}]"
-            a.append(s)
-            if self.options.pretty:
-                # Add source code fragment and a location marker.
-                if severity == "error" and source_lines and line > 0:
-                    source_line = source_lines[line - 1]
-                    source_line_expanded = source_line.expandtabs()
-                    if column < 0:
-                        # Something went wrong, take first non-empty column.
-                        column = len(source_line) - len(source_line.lstrip())
-
-                    # Shifts column after tab expansion
-                    column = len(source_line[:column].expandtabs())
-                    end_column = len(source_line[:end_column].expandtabs())
-
-                    # Note, currently coloring uses the offset to detect source snippets,
-                    # so these offsets should not be arbitrary.
-                    a.append(" " * DEFAULT_SOURCE_OFFSET + source_line_expanded)
-                    marker = "^"
-                    if end_line == line and end_column > column:
-                        marker = f'^{"~" * (end_column - column - 1)}'
-                    a.append(" " * (DEFAULT_SOURCE_OFFSET + column) + marker)
-        return a
-
-    def file_messages(self, path: str) -> list[str]:
-        """Return a string list of new error messages from a given file.
-
-        Use a form suitable for displaying to the user.
-        """
-        if path not in self.error_info_map:
-            return []
-        self.flushed_files.add(path)
-        source_lines = None
-        if self.options.pretty and self.read_source:
-            source_lines = self.read_source(path)
-        return self.format_messages(self.error_info_map[path], source_lines)
-
-    def new_messages(self) -> list[str]:
-        """Return a string list of new error messages.
-
-        Use a form suitable for displaying to the user.
-        Errors from different files are ordered based on the order in which
-        they first generated an error.
-        """
-        msgs = []
-        for path in self.error_info_map.keys():
-            if path not in self.flushed_files:
-                msgs.extend(self.file_messages(path))
-        return msgs
-
-    def targets(self) -> set[str]:
-        """Return a set of all targets that contain errors."""
-        # TODO: Make sure that either target is always defined or that not being defined
-        #       is okay for fine-grained incremental checking.
-        return {
-            info.target for errs in self.error_info_map.values() for info in errs if info.target
-        }
-
-    def render_messages(self, errors: list[ErrorInfo]) -> list[ErrorTuple]:
-        """Translate the messages into a sequence of tuples.
-
-        Each tuple is of form (path, line, col, severity, message, allow_dups, code).
-        The rendered sequence includes information about error contexts.
-        The path item may be None. If the line item is negative, the
-        line number is not defined for the tuple.
-        """
-        result: list[ErrorTuple] = []
-        prev_import_context: list[tuple[str, int]] = []
-        prev_function_or_member: str | None = None
-        prev_type: str | None = None
-
-        for e in errors:
-            # Report module import context, if different from previous message.
-            if not self.options.show_error_context:
-                pass
-            elif e.import_ctx != prev_import_context:
-                last = len(e.import_ctx) - 1
-                i = last
-                while i >= 0:
-                    path, line = e.import_ctx[i]
-                    fmt = "{}:{}: note: In module imported here"
-                    if i < last:
-                        fmt = "{}:{}: note: ... from here"
-                    if i > 0:
-                        fmt += ","
-                    else:
-                        fmt += ":"
-                    # Remove prefix to ignore from path (if present) to
-                    # simplify path.
-                    path = remove_path_prefix(path, self.ignore_prefix)
-                    result.append(
-                        (None, -1, -1, -1, -1, "note", fmt.format(path, line), e.allow_dups, None)
-                    )
-                    i -= 1
-
-            file = self.simplify_path(e.file)
-
-            # Report context within a source file.
-            if not self.options.show_error_context:
-                pass
-            elif e.function_or_member != prev_function_or_member or e.type != prev_type:
-                if e.function_or_member is None:
-                    if e.type is None:
-                        result.append(
-                            (file, -1, -1, -1, -1, "note", "At top level:", e.allow_dups, None)
-                        )
-                    else:
-                        result.append(
-                            (
-                                file,
-                                -1,
-                                -1,
-                                -1,
-                                -1,
-                                "note",
-                                f'In class "{e.type}":',
-                                e.allow_dups,
-                                None,
-                            )
-                        )
-                else:
-                    if e.type is None:
-                        result.append(
-                            (
-                                file,
-                                -1,
-                                -1,
-                                -1,
-                                -1,
-                                "note",
-                                f'In function "{e.function_or_member}":',
-                                e.allow_dups,
-                                None,
-                            )
-                        )
-                    else:
-                        result.append(
-                            (
-                                file,
-                                -1,
-                                -1,
-                                -1,
-                                -1,
-                                "note",
-                                'In member "{}" of class "{}":'.format(
-                                    e.function_or_member, e.type
-                                ),
-                                e.allow_dups,
-                                None,
-                            )
-                        )
-            elif e.type != prev_type:
-                if e.type is None:
-                    result.append(
-                        (file, -1, -1, -1, -1, "note", "At top level:", e.allow_dups, None)
-                    )
-                else:
-                    result.append(
-                        (file, -1, -1, -1, -1, "note", f'In class "{e.type}":', e.allow_dups, None)
-                    )
-
-            if isinstance(e.message, ErrorMessage):
-                result.append(
-                    (
-                        file,
-                        e.line,
-                        e.column,
-                        e.end_line,
-                        e.end_column,
-                        e.severity,
-                        e.message.value,
-                        e.allow_dups,
-                        e.code,
-                    )
-                )
-            else:
-                result.append(
-                    (
-                        file,
-                        e.line,
-                        e.column,
-                        e.end_line,
-                        e.end_column,
-                        e.severity,
-                        e.message,
-                        e.allow_dups,
-                        e.code,
-                    )
-                )
-
-            prev_import_context = e.import_ctx
-            prev_function_or_member = e.function_or_member
-            prev_type = e.type
-
-        return result
-
-    def sort_messages(self, errors: list[ErrorInfo]) -> list[ErrorInfo]:
-        """Sort an array of error messages locally by line number.
-
-        I.e., sort a run of consecutive messages with the same
-        context by line number, but otherwise retain the general
-        ordering of the messages.
-        """
-        result: list[ErrorInfo] = []
-        i = 0
-        while i < len(errors):
-            i0 = i
-            # Find neighbouring errors with the same context and file.
-            while (
-                i + 1 < len(errors)
-                and errors[i + 1].import_ctx == errors[i].import_ctx
-                and errors[i + 1].file == errors[i].file
-            ):
-                i += 1
-            i += 1
-
-            # Sort the errors specific to a file according to line number and column.
-            a = sorted(errors[i0:i], key=lambda x: (x.line, x.column))
-            a = self.sort_within_context(a)
-            result.extend(a)
-        return result
-
-    def sort_within_context(self, errors: list[ErrorInfo]) -> list[ErrorInfo]:
-        """For the same location decide which messages to show first/last.
-
-        Currently, we only compare within the same error code, to decide the
-        order of various additional notes.
-        """
-        result = []
-        i = 0
-        while i < len(errors):
-            i0 = i
-            # Find neighbouring errors with the same position and error code.
-            while (
-                i + 1 < len(errors)
-                and errors[i + 1].line == errors[i].line
-                and errors[i + 1].column == errors[i].column
-                and errors[i + 1].end_line == errors[i].end_line
-                and errors[i + 1].end_column == errors[i].end_column
-                and errors[i + 1].code == errors[i].code
-            ):
-                i += 1
-            i += 1
-
-            # Sort the messages specific to a given error by priority.
-            a = sorted(errors[i0:i], key=lambda x: x.priority)
-            result.extend(a)
-        return result
-
-    def remove_duplicates(self, errors: list[ErrorTuple]) -> list[ErrorTuple]:
-        """Remove duplicates from a sorted error list."""
-        res: list[ErrorTuple] = []
-        i = 0
-        while i < len(errors):
-            dup = False
-            # Use slightly special formatting for member conflicts reporting.
-            conflicts_notes = False
-            j = i - 1
-            # Find duplicates, unless duplicates are allowed.
-            if not errors[i][7]:
-                while j >= 0 and errors[j][0] == errors[i][0]:
-                    if errors[j][6].strip() == "Got:":
-                        conflicts_notes = True
-                    j -= 1
-                j = i - 1
-                while j >= 0 and errors[j][0] == errors[i][0] and errors[j][1] == errors[i][1]:
-                    if (
-                        errors[j][5] == errors[i][5]
-                        and
-                        # Allow duplicate notes in overload conflicts reporting.
-                        not (
-                            (errors[i][5] == "note" and errors[i][6].strip() in allowed_duplicates)
-                            or (errors[i][6].strip().startswith("def ") and conflicts_notes)
-                        )
-                        and errors[j][6] == errors[i][6]
-                    ):  # ignore column
-                        dup = True
-                        break
-                    j -= 1
-            if not dup:
-                res.append(errors[i])
-            i += 1
-        return res
-
-
-class CompileError(Exception):
-    """Exception raised when there is a compile error.
-
-    It can be a parse, semantic analysis, type check or other
-    compilation-related error.
-
-    CompileErrors raised from an errors object carry all of the
-    messages that have not been reported out by error streaming.
-    This is patched up by build.build to contain either all error
-    messages (if errors were streamed) or none (if they were not).
-
-    """
-
-    messages: list[str]
-    use_stdout = False
-    # Can be set in case there was a module with a blocking error
-    module_with_blocker: str | None = None
-
-    def __init__(
-        self, messages: list[str], use_stdout: bool = False, module_with_blocker: str | None = None
-    ) -> None:
-        super().__init__("\n".join(messages))
-        self.messages = messages
-        self.use_stdout = use_stdout
-        self.module_with_blocker = module_with_blocker
-
-
-def remove_path_prefix(path: str, prefix: str | None) -> str:
-    """If path starts with prefix, return copy of path with the prefix removed.
-    Otherwise, return path. If path is None, return None.
-    """
-    if prefix is not None and path.startswith(prefix):
-        return path[len(prefix) :]
-    else:
-        return path
-
-
-def report_internal_error(
-    err: Exception,
-    file: str | None,
-    line: int,
-    errors: Errors,
-    options: Options,
-    stdout: TextIO | None = None,
-    stderr: TextIO | None = None,
-) -> NoReturn:
-    """Report internal error and exit.
-
-    This optionally starts pdb or shows a traceback.
-    """
-    stdout = stdout or sys.stdout
-    stderr = stderr or sys.stderr
-    # Dump out errors so far, they often provide a clue.
-    # But catch unexpected errors rendering them.
-    try:
-        for msg in errors.new_messages():
-            print(msg)
-    except Exception as e:
-        print("Failed to dump errors:", repr(e), file=stderr)
-
-    # Compute file:line prefix for official-looking error messages.
-    if file:
-        if line:
-            prefix = f"{file}:{line}: "
-        else:
-            prefix = f"{file}: "
-    else:
-        prefix = ""
-
-    # Print "INTERNAL ERROR" message.
-    print(
-        f"{prefix}error: INTERNAL ERROR --",
-        "Please try using mypy master on GitHub:\n"
-        "https://mypy.readthedocs.io/en/stable/common_issues.html"
-        "#using-a-development-mypy-build",
-        file=stderr,
-    )
-    if options.show_traceback:
-        print("Please report a bug at https://github.com/python/mypy/issues", file=stderr)
-    else:
-        print(
-            "If this issue continues with mypy master, "
-            "please report a bug at https://github.com/python/mypy/issues",
-            file=stderr,
-        )
-    print(f"version: {mypy_version}", file=stderr)
-
-    # If requested, drop into pdb. This overrides show_tb.
-    if options.pdb:
-        print("Dropping into pdb", file=stderr)
-        import pdb
-
-        pdb.post_mortem(sys.exc_info()[2])
-
-    # If requested, print traceback, else print note explaining how to get one.
-    if options.raise_exceptions:
-        raise err
-    if not options.show_traceback:
-        if not options.pdb:
-            print(
-                "{}: note: please use --show-traceback to print a traceback "
-                "when reporting a bug".format(prefix),
-                file=stderr,
-            )
-    else:
-        tb = traceback.extract_stack()[:-2]
-        tb2 = traceback.extract_tb(sys.exc_info()[2])
-        print("Traceback (most recent call last):")
-        for s in traceback.format_list(tb + tb2):
-            print(s.rstrip("\n"))
-        print(f"{type(err).__name__}: {err}", file=stdout)
-        print(f"{prefix}: note: use --pdb to drop into pdb", file=stderr)
-
-    # Exit.  The caller has nothing more to say.
-    # We use exit code 2 to signal that this is no ordinary error.
-    raise SystemExit(2)