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

jaclang/vendor/mypy/main.py

@@ -1,1574 +0,0 @@
-"""Mypy type checker command line tool."""
-
-from __future__ import annotations
-
-import argparse
-import os
-import subprocess
-import sys
-import time
-from collections import defaultdict
-from gettext import gettext
-from typing import IO, Any, Final, NoReturn, Sequence, TextIO
-
-from mypy import build, defaults, state, util
-from mypy.config_parser import (
-    get_config_module_names,
-    parse_config_file,
-    parse_version,
-    validate_package_allow_list,
-)
-from mypy.errorcodes import error_codes
-from mypy.errors import CompileError
-from mypy.find_sources import InvalidSourceList, create_source_list
-from mypy.fscache import FileSystemCache
-from mypy.modulefinder import BuildSource, FindModuleCache, SearchPaths, get_search_dirs, mypy_path
-from mypy.options import COMPLETE_FEATURES, INCOMPLETE_FEATURES, BuildType, Options
-from mypy.split_namespace import SplitNamespace
-from mypy.version import __version__
-
-orig_stat: Final = os.stat
-MEM_PROFILE: Final = False  # If True, dump memory profile
-
-
-def stat_proxy(path: str) -> os.stat_result:
-    try:
-        st = orig_stat(path)
-    except OSError as err:
-        print(f"stat({path!r}) -> {err}")
-        raise
-    else:
-        print(
-            "stat(%r) -> (st_mode=%o, st_mtime=%d, st_size=%d)"
-            % (path, st.st_mode, st.st_mtime, st.st_size)
-        )
-        return st
-
-
-def main(
-    *,
-    args: list[str] | None = None,
-    stdout: TextIO = sys.stdout,
-    stderr: TextIO = sys.stderr,
-    clean_exit: bool = False,
-) -> None:
-    """Main entry point to the type checker.
-
-    Args:
-        args: Custom command-line arguments.  If not given, sys.argv[1:] will
-            be used.
-        clean_exit: Don't hard kill the process on exit. This allows catching
-            SystemExit.
-    """
-    util.check_python_version("mypy")
-    t0 = time.time()
-    # To log stat() calls: os.stat = stat_proxy
-    sys.setrecursionlimit(2**14)
-    if args is None:
-        args = sys.argv[1:]
-
-    fscache = FileSystemCache()
-    sources, options = process_options(args, stdout=stdout, stderr=stderr, fscache=fscache)
-    if clean_exit:
-        options.fast_exit = False
-
-    formatter = util.FancyFormatter(stdout, stderr, options.hide_error_codes)
-
-    if options.install_types and (stdout is not sys.stdout or stderr is not sys.stderr):
-        # Since --install-types performs user input, we want regular stdout and stderr.
-        fail("error: --install-types not supported in this mode of running mypy", stderr, options)
-
-    if options.non_interactive and not options.install_types:
-        fail("error: --non-interactive is only supported with --install-types", stderr, options)
-
-    if options.install_types and not options.incremental:
-        fail(
-            "error: --install-types not supported with incremental mode disabled", stderr, options
-        )
-
-    if options.install_types and options.python_executable is None:
-        fail(
-            "error: --install-types not supported without python executable or site packages",
-            stderr,
-            options,
-        )
-
-    if options.install_types and not sources:
-        install_types(formatter, options, non_interactive=options.non_interactive)
-        return
-
-    res, messages, blockers = run_build(sources, options, fscache, t0, stdout, stderr)
-
-    if options.non_interactive:
-        missing_pkgs = read_types_packages_to_install(options.cache_dir, after_run=True)
-        if missing_pkgs:
-            # Install missing type packages and rerun build.
-            install_types(formatter, options, after_run=True, non_interactive=True)
-            fscache.flush()
-            print()
-            res, messages, blockers = run_build(sources, options, fscache, t0, stdout, stderr)
-        show_messages(messages, stderr, formatter, options)
-
-    if MEM_PROFILE:
-        from mypy.memprofile import print_memory_profile
-
-        print_memory_profile()
-
-    code = 0
-    n_errors, n_notes, n_files = util.count_stats(messages)
-    if messages and n_notes < len(messages):
-        code = 2 if blockers else 1
-    if options.error_summary:
-        if n_errors:
-            summary = formatter.format_error(
-                n_errors, n_files, len(sources), blockers=blockers, use_color=options.color_output
-            )
-            stdout.write(summary + "\n")
-        # Only notes should also output success
-        elif not messages or n_notes == len(messages):
-            stdout.write(formatter.format_success(len(sources), options.color_output) + "\n")
-        stdout.flush()
-
-    if options.install_types and not options.non_interactive:
-        result = install_types(formatter, options, after_run=True, non_interactive=False)
-        if result:
-            print()
-            print("note: Run mypy again for up-to-date results with installed types")
-            code = 2
-
-    if options.fast_exit:
-        # Exit without freeing objects -- it's faster.
-        #
-        # NOTE: We don't flush all open files on exit (or run other destructors)!
-        util.hard_exit(code)
-    elif code:
-        sys.exit(code)
-
-    # HACK: keep res alive so that mypyc won't free it before the hard_exit
-    list([res])  # noqa: C410
-
-
-def run_build(
-    sources: list[BuildSource],
-    options: Options,
-    fscache: FileSystemCache,
-    t0: float,
-    stdout: TextIO,
-    stderr: TextIO,
-) -> tuple[build.BuildResult | None, list[str], bool]:
-    formatter = util.FancyFormatter(stdout, stderr, options.hide_error_codes)
-
-    messages = []
-    messages_by_file = defaultdict(list)
-
-    def flush_errors(filename: str | None, new_messages: list[str], serious: bool) -> None:
-        if options.pretty:
-            new_messages = formatter.fit_in_terminal(new_messages)
-        messages.extend(new_messages)
-        if new_messages:
-            messages_by_file[filename].extend(new_messages)
-        if options.non_interactive:
-            # Collect messages and possibly show them later.
-            return
-        f = stderr if serious else stdout
-        show_messages(new_messages, f, formatter, options)
-
-    serious = False
-    blockers = False
-    res = None
-    try:
-        # Keep a dummy reference (res) for memory profiling afterwards, as otherwise
-        # the result could be freed.
-        res = build.build(sources, options, None, flush_errors, fscache, stdout, stderr)
-    except CompileError as e:
-        blockers = True
-        if not e.use_stdout:
-            serious = True
-    if (
-        options.warn_unused_configs
-        and options.unused_configs
-        and not options.incremental
-        and not options.non_interactive
-    ):
-        print(
-            "Warning: unused section(s) in {}: {}".format(
-                options.config_file,
-                get_config_module_names(
-                    options.config_file,
-                    [
-                        glob
-                        for glob in options.per_module_options.keys()
-                        if glob in options.unused_configs
-                    ],
-                ),
-            ),
-            file=stderr,
-        )
-    maybe_write_junit_xml(time.time() - t0, serious, messages, messages_by_file, options)
-    return res, messages, blockers
-
-
-def show_messages(
-    messages: list[str], f: TextIO, formatter: util.FancyFormatter, options: Options
-) -> None:
-    for msg in messages:
-        if options.color_output:
-            msg = formatter.colorize(msg)
-        f.write(msg + "\n")
-    f.flush()
-
-
-# Make the help output a little less jarring.
-class AugmentedHelpFormatter(argparse.RawDescriptionHelpFormatter):
-    def __init__(self, prog: str) -> None:
-        super().__init__(prog=prog, max_help_position=28)
-
-    def _fill_text(self, text: str, width: int, indent: str) -> str:
-        if "\n" in text:
-            # Assume we want to manually format the text
-            return super()._fill_text(text, width, indent)
-        else:
-            # Assume we want argparse to manage wrapping, indenting, and
-            # formatting the text for us.
-            return argparse.HelpFormatter._fill_text(self, text, width, indent)
-
-
-# Define pairs of flag prefixes with inverse meaning.
-flag_prefix_pairs: Final = [("allow", "disallow"), ("show", "hide")]
-flag_prefix_map: Final[dict[str, str]] = {}
-for a, b in flag_prefix_pairs:
-    flag_prefix_map[a] = b
-    flag_prefix_map[b] = a
-
-
-def invert_flag_name(flag: str) -> str:
-    split = flag[2:].split("-", 1)
-    if len(split) == 2:
-        prefix, rest = split
-        if prefix in flag_prefix_map:
-            return f"--{flag_prefix_map[prefix]}-{rest}"
-        elif prefix == "no":
-            return f"--{rest}"
-
-    return f"--no-{flag[2:]}"
-
-
-class PythonExecutableInferenceError(Exception):
-    """Represents a failure to infer the version or executable while searching."""
-
-
-def python_executable_prefix(v: str) -> list[str]:
-    if sys.platform == "win32":
-        # on Windows, all Python executables are named `python`. To handle this, there
-        # is the `py` launcher, which can be passed a version e.g. `py -3.8`, and it will
-        # execute an installed Python 3.8 interpreter. See also:
-        # https://docs.python.org/3/using/windows.html#python-launcher-for-windows
-        return ["py", f"-{v}"]
-    else:
-        return [f"python{v}"]
-
-
-def _python_executable_from_version(python_version: tuple[int, int]) -> str:
-    if sys.version_info[:2] == python_version:
-        return sys.executable
-    str_ver = ".".join(map(str, python_version))
-    try:
-        sys_exe = (
-            subprocess.check_output(
-                python_executable_prefix(str_ver) + ["-c", "import sys; print(sys.executable)"],
-                stderr=subprocess.STDOUT,
-            )
-            .decode()
-            .strip()
-        )
-        return sys_exe
-    except (subprocess.CalledProcessError, FileNotFoundError) as e:
-        raise PythonExecutableInferenceError(
-            "failed to find a Python executable matching version {},"
-            " perhaps try --python-executable, or --no-site-packages?".format(python_version)
-        ) from e
-
-
-def infer_python_executable(options: Options, special_opts: argparse.Namespace) -> None:
-    """Infer the Python executable from the given version.
-
-    This function mutates options based on special_opts to infer the correct Python executable
-    to use.
-    """
-    # TODO: (ethanhs) Look at folding these checks and the site packages subprocess calls into
-    # one subprocess call for speed.
-
-    # Use the command line specified executable, or fall back to one set in the
-    # config file. If an executable is not specified, infer it from the version
-    # (unless no_executable is set)
-    python_executable = special_opts.python_executable or options.python_executable
-
-    if python_executable is None:
-        if not special_opts.no_executable and not options.no_site_packages:
-            python_executable = _python_executable_from_version(options.python_version)
-    options.python_executable = python_executable
-
-
-HEADER: Final = """%(prog)s [-h] [-v] [-V] [more options; see below]
-            [-m MODULE] [-p PACKAGE] [-c PROGRAM_TEXT] [files ...]"""
-
-
-DESCRIPTION: Final = """
-Mypy is a program that will type check your Python code.
-
-Pass in any files or folders you want to type check. Mypy will
-recursively traverse any provided folders to find .py files:
-
-    $ mypy my_program.py my_src_folder
-
-For more information on getting started, see:
-
-- https://mypy.readthedocs.io/en/stable/getting_started.html
-
-For more details on both running mypy and using the flags below, see:
-
-- https://mypy.readthedocs.io/en/stable/running_mypy.html
-- https://mypy.readthedocs.io/en/stable/command_line.html
-
-You can also use a config file to configure mypy instead of using
-command line flags. For more details, see:
-
-- https://mypy.readthedocs.io/en/stable/config_file.html
-"""
-
-FOOTER: Final = """Environment variables:
-  Define MYPYPATH for additional module search path entries.
-  Define MYPY_CACHE_DIR to override configuration cache_dir path."""
-
-
-class CapturableArgumentParser(argparse.ArgumentParser):
-    """Override ArgumentParser methods that use sys.stdout/sys.stderr directly.
-
-    This is needed because hijacking sys.std* is not thread-safe,
-    yet output must be captured to properly support mypy.api.run.
-    """
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        self.stdout = kwargs.pop("stdout", sys.stdout)
-        self.stderr = kwargs.pop("stderr", sys.stderr)
-        super().__init__(*args, **kwargs)
-
-    # =====================
-    # Help-printing methods
-    # =====================
-    def print_usage(self, file: IO[str] | None = None) -> None:
-        if file is None:
-            file = self.stdout
-        self._print_message(self.format_usage(), file)
-
-    def print_help(self, file: IO[str] | None = None) -> None:
-        if file is None:
-            file = self.stdout
-        self._print_message(self.format_help(), file)
-
-    def _print_message(self, message: str, file: IO[str] | None = None) -> None:
-        if message:
-            if file is None:
-                file = self.stderr
-            file.write(message)
-
-    # ===============
-    # Exiting methods
-    # ===============
-    def exit(self, status: int = 0, message: str | None = None) -> NoReturn:
-        if message:
-            self._print_message(message, self.stderr)
-        sys.exit(status)
-
-    def error(self, message: str) -> NoReturn:
-        """error(message: string)
-
-        Prints a usage message incorporating the message to stderr and
-        exits.
-
-        If you override this in a subclass, it should not return -- it
-        should either exit or raise an exception.
-        """
-        self.print_usage(self.stderr)
-        args = {"prog": self.prog, "message": message}
-        self.exit(2, gettext("%(prog)s: error: %(message)s\n") % args)
-
-
-class CapturableVersionAction(argparse.Action):
-    """Supplement CapturableArgumentParser to handle --version.
-
-    This is nearly identical to argparse._VersionAction except,
-    like CapturableArgumentParser, it allows output to be captured.
-
-    Another notable difference is that version is mandatory.
-    This allows removing a line in __call__ that falls back to parser.version
-    (which does not appear to exist).
-    """
-
-    def __init__(
-        self,
-        option_strings: Sequence[str],
-        version: str,
-        dest: str = argparse.SUPPRESS,
-        default: str = argparse.SUPPRESS,
-        help: str = "show program's version number and exit",
-        stdout: IO[str] | None = None,
-    ) -> None:
-        super().__init__(
-            option_strings=option_strings, dest=dest, default=default, nargs=0, help=help
-        )
-        self.version = version
-        self.stdout = stdout or sys.stdout
-
-    def __call__(
-        self,
-        parser: argparse.ArgumentParser,
-        namespace: argparse.Namespace,
-        values: str | Sequence[Any] | None,
-        option_string: str | None = None,
-    ) -> NoReturn:
-        formatter = parser._get_formatter()
-        formatter.add_text(self.version)
-        parser._print_message(formatter.format_help(), self.stdout)
-        parser.exit()
-
-
-def process_options(
-    args: list[str],
-    stdout: TextIO | None = None,
-    stderr: TextIO | None = None,
-    require_targets: bool = True,
-    server_options: bool = False,
-    fscache: FileSystemCache | None = None,
-    program: str = "mypy",
-    header: str = HEADER,
-) -> tuple[list[BuildSource], Options]:
-    """Parse command line arguments.
-
-    If a FileSystemCache is passed in, and package_root options are given,
-    call fscache.set_package_root() to set the cache's package root.
-    """
-    stdout = stdout or sys.stdout
-    stderr = stderr or sys.stderr
-
-    parser = CapturableArgumentParser(
-        prog=program,
-        usage=header,
-        description=DESCRIPTION,
-        epilog=FOOTER,
-        fromfile_prefix_chars="@",
-        formatter_class=AugmentedHelpFormatter,
-        add_help=False,
-        stdout=stdout,
-        stderr=stderr,
-    )
-
-    strict_flag_names: list[str] = []
-    strict_flag_assignments: list[tuple[str, bool]] = []
-
-    def add_invertible_flag(
-        flag: str,
-        *,
-        inverse: str | None = None,
-        default: bool,
-        dest: str | None = None,
-        help: str,
-        strict_flag: bool = False,
-        group: argparse._ActionsContainer | None = None,
-    ) -> None:
-        if inverse is None:
-            inverse = invert_flag_name(flag)
-        if group is None:
-            group = parser
-
-        if help is not argparse.SUPPRESS:
-            help += f" (inverse: {inverse})"
-
-        arg = group.add_argument(
-            flag, action="store_false" if default else "store_true", dest=dest, help=help
-        )
-        dest = arg.dest
-        group.add_argument(
-            inverse,
-            action="store_true" if default else "store_false",
-            dest=dest,
-            help=argparse.SUPPRESS,
-        )
-        if strict_flag:
-            assert dest is not None
-            strict_flag_names.append(flag)
-            strict_flag_assignments.append((dest, not default))
-
-    # Unless otherwise specified, arguments will be parsed directly onto an
-    # Options object.  Options that require further processing should have
-    # their `dest` prefixed with `special-opts:`, which will cause them to be
-    # parsed into the separate special_opts namespace object.
-
-    # Note: we have a style guide for formatting the mypy --help text. See
-    # https://github.com/python/mypy/wiki/Documentation-Conventions
-
-    general_group = parser.add_argument_group(title="Optional arguments")
-    general_group.add_argument(
-        "-h", "--help", action="help", help="Show this help message and exit"
-    )
-    general_group.add_argument(
-        "-v", "--verbose", action="count", dest="verbosity", help="More verbose messages"
-    )
-
-    compilation_status = "no" if __file__.endswith(".py") else "yes"
-    general_group.add_argument(
-        "-V",
-        "--version",
-        action=CapturableVersionAction,
-        version="%(prog)s " + __version__ + f" (compiled: {compilation_status})",
-        help="Show program's version number and exit",
-        stdout=stdout,
-    )
-
-    config_group = parser.add_argument_group(
-        title="Config file",
-        description="Use a config file instead of command line arguments. "
-        "This is useful if you are using many flags or want "
-        "to set different options per each module.",
-    )
-    config_group.add_argument(
-        "--config-file",
-        help="Configuration file, must have a [mypy] section "
-        "(defaults to {})".format(", ".join(defaults.CONFIG_FILES)),
-    )
-    add_invertible_flag(
-        "--warn-unused-configs",
-        default=False,
-        strict_flag=True,
-        help="Warn about unused '[mypy-<pattern>]' or '[[tool.mypy.overrides]]' "
-        "config sections",
-        group=config_group,
-    )
-
-    imports_group = parser.add_argument_group(
-        title="Import discovery", description="Configure how imports are discovered and followed."
-    )
-    add_invertible_flag(
-        "--no-namespace-packages",
-        dest="namespace_packages",
-        default=True,
-        help="Support namespace packages (PEP 420, __init__.py-less)",
-        group=imports_group,
-    )
-    imports_group.add_argument(
-        "--ignore-missing-imports",
-        action="store_true",
-        help="Silently ignore imports of missing modules",
-    )
-    imports_group.add_argument(
-        "--follow-imports",
-        choices=["normal", "silent", "skip", "error"],
-        default="normal",
-        help="How to treat imports (default normal)",
-    )
-    imports_group.add_argument(
-        "--python-executable",
-        action="store",
-        metavar="EXECUTABLE",
-        help="Python executable used for finding PEP 561 compliant installed"
-        " packages and stubs",
-        dest="special-opts:python_executable",
-    )
-    imports_group.add_argument(
-        "--no-site-packages",
-        action="store_true",
-        dest="special-opts:no_executable",
-        help="Do not search for installed PEP 561 compliant packages",
-    )
-    imports_group.add_argument(
-        "--no-silence-site-packages",
-        action="store_true",
-        help="Do not silence errors in PEP 561 compliant installed packages",
-    )
-
-    platform_group = parser.add_argument_group(
-        title="Platform configuration",
-        description="Type check code assuming it will be run under certain "
-        "runtime conditions. By default, mypy assumes your code "
-        "will be run using the same operating system and Python "
-        "version you are using to run mypy itself.",
-    )
-    platform_group.add_argument(
-        "--python-version",
-        type=parse_version,
-        metavar="x.y",
-        help="Type check code assuming it will be running on Python x.y",
-        dest="special-opts:python_version",
-    )
-    platform_group.add_argument(
-        "--platform",
-        action="store",
-        metavar="PLATFORM",
-        help="Type check special-cased code for the given OS platform "
-        "(defaults to sys.platform)",
-    )
-    platform_group.add_argument(
-        "--always-true",
-        metavar="NAME",
-        action="append",
-        default=[],
-        help="Additional variable to be considered True (may be repeated)",
-    )
-    platform_group.add_argument(
-        "--always-false",
-        metavar="NAME",
-        action="append",
-        default=[],
-        help="Additional variable to be considered False (may be repeated)",
-    )
-
-    disallow_any_group = parser.add_argument_group(
-        title="Disallow dynamic typing",
-        description="Disallow the use of the dynamic 'Any' type under certain conditions.",
-    )
-    disallow_any_group.add_argument(
-        "--disallow-any-unimported",
-        default=False,
-        action="store_true",
-        help="Disallow Any types resulting from unfollowed imports",
-    )
-    disallow_any_group.add_argument(
-        "--disallow-any-expr",
-        default=False,
-        action="store_true",
-        help="Disallow all expressions that have type Any",
-    )
-    disallow_any_group.add_argument(
-        "--disallow-any-decorated",
-        default=False,
-        action="store_true",
-        help="Disallow functions that have Any in their signature "
-        "after decorator transformation",
-    )
-    disallow_any_group.add_argument(
-        "--disallow-any-explicit",
-        default=False,
-        action="store_true",
-        help="Disallow explicit Any in type positions",
-    )
-    add_invertible_flag(
-        "--disallow-any-generics",
-        default=False,
-        strict_flag=True,
-        help="Disallow usage of generic types that do not specify explicit type parameters",
-        group=disallow_any_group,
-    )
-    add_invertible_flag(
-        "--disallow-subclassing-any",
-        default=False,
-        strict_flag=True,
-        help="Disallow subclassing values of type 'Any' when defining classes",
-        group=disallow_any_group,
-    )
-
-    untyped_group = parser.add_argument_group(
-        title="Untyped definitions and calls",
-        description="Configure how untyped definitions and calls are handled. "
-        "Note: by default, mypy ignores any untyped function definitions "
-        "and assumes any calls to such functions have a return "
-        "type of 'Any'.",
-    )
-    add_invertible_flag(
-        "--disallow-untyped-calls",
-        default=False,
-        strict_flag=True,
-        help="Disallow calling functions without type annotations"
-        " from functions with type annotations",
-        group=untyped_group,
-    )
-    untyped_group.add_argument(
-        "--untyped-calls-exclude",
-        metavar="MODULE",
-        action="append",
-        default=[],
-        help="Disable --disallow-untyped-calls for functions/methods coming"
-        " from specific package, module, or class",
-    )
-    add_invertible_flag(
-        "--disallow-untyped-defs",
-        default=False,
-        strict_flag=True,
-        help="Disallow defining functions without type annotations"
-        " or with incomplete type annotations",
-        group=untyped_group,
-    )
-    add_invertible_flag(
-        "--disallow-incomplete-defs",
-        default=False,
-        strict_flag=True,
-        help="Disallow defining functions with incomplete type annotations "
-        "(while still allowing entirely unannotated definitions)",
-        group=untyped_group,
-    )
-    add_invertible_flag(
-        "--check-untyped-defs",
-        default=False,
-        strict_flag=True,
-        help="Type check the interior of functions without type annotations",
-        group=untyped_group,
-    )
-    add_invertible_flag(
-        "--disallow-untyped-decorators",
-        default=False,
-        strict_flag=True,
-        help="Disallow decorating typed functions with untyped decorators",
-        group=untyped_group,
-    )
-
-    none_group = parser.add_argument_group(
-        title="None and Optional handling",
-        description="Adjust how values of type 'None' are handled. For more context on "
-        "how mypy handles values of type 'None', see: "
-        "https://mypy.readthedocs.io/en/stable/kinds_of_types.html#no-strict-optional",
-    )
-    add_invertible_flag(
-        "--implicit-optional",
-        default=False,
-        help="Assume arguments with default values of None are Optional",
-        group=none_group,
-    )
-    none_group.add_argument("--strict-optional", action="store_true", help=argparse.SUPPRESS)
-    none_group.add_argument(
-        "--no-strict-optional",
-        action="store_false",
-        dest="strict_optional",
-        help="Disable strict Optional checks (inverse: --strict-optional)",
-    )
-
-    add_invertible_flag(
-        "--force-uppercase-builtins", default=False, help=argparse.SUPPRESS, group=none_group
-    )
-
-    add_invertible_flag(
-        "--force-union-syntax", default=False, help=argparse.SUPPRESS, group=none_group
-    )
-
-    lint_group = parser.add_argument_group(
-        title="Configuring warnings",
-        description="Detect code that is sound but redundant or problematic.",
-    )
-    add_invertible_flag(
-        "--warn-redundant-casts",
-        default=False,
-        strict_flag=True,
-        help="Warn about casting an expression to its inferred type",
-        group=lint_group,
-    )
-    add_invertible_flag(
-        "--warn-unused-ignores",
-        default=False,
-        strict_flag=True,
-        help="Warn about unneeded '# type: ignore' comments",
-        group=lint_group,
-    )
-    add_invertible_flag(
-        "--no-warn-no-return",
-        dest="warn_no_return",
-        default=True,
-        help="Do not warn about functions that end without returning",
-        group=lint_group,
-    )
-    add_invertible_flag(
-        "--warn-return-any",
-        default=False,
-        strict_flag=True,
-        help="Warn about returning values of type Any from non-Any typed functions",
-        group=lint_group,
-    )
-    add_invertible_flag(
-        "--warn-unreachable",
-        default=False,
-        strict_flag=False,
-        help="Warn about statements or expressions inferred to be unreachable",
-        group=lint_group,
-    )
-
-    # Note: this group is intentionally added here even though we don't add
-    # --strict to this group near the end.
-    #
-    # That way, this group will appear after the various strictness groups
-    # but before the remaining flags.
-    # We add `--strict` near the end so we don't accidentally miss any strictness
-    # flags that are added after this group.
-    strictness_group = parser.add_argument_group(title="Miscellaneous strictness flags")
-
-    add_invertible_flag(
-        "--allow-untyped-globals",
-        default=False,
-        strict_flag=False,
-        help="Suppress toplevel errors caused by missing annotations",
-        group=strictness_group,
-    )
-
-    add_invertible_flag(
-        "--allow-redefinition",
-        default=False,
-        strict_flag=False,
-        help="Allow unconditional variable redefinition with a new type",
-        group=strictness_group,
-    )
-
-    add_invertible_flag(
-        "--no-implicit-reexport",
-        default=True,
-        strict_flag=True,
-        dest="implicit_reexport",
-        help="Treat imports as private unless aliased",
-        group=strictness_group,
-    )
-
-    add_invertible_flag(
-        "--strict-equality",
-        default=False,
-        strict_flag=True,
-        help="Prohibit equality, identity, and container checks for non-overlapping types",
-        group=strictness_group,
-    )
-
-    add_invertible_flag(
-        "--extra-checks",
-        default=False,
-        strict_flag=True,
-        help="Enable additional checks that are technically correct but may be impractical "
-        "in real code. For example, this prohibits partial overlap in TypedDict updates, "
-        "and makes arguments prepended via Concatenate positional-only",
-        group=strictness_group,
-    )
-
-    strict_help = "Strict mode; enables the following flags: {}".format(
-        ", ".join(strict_flag_names)
-    )
-    strictness_group.add_argument(
-        "--strict", action="store_true", dest="special-opts:strict", help=strict_help
-    )
-
-    strictness_group.add_argument(
-        "--disable-error-code",
-        metavar="NAME",
-        action="append",
-        default=[],
-        help="Disable a specific error code",
-    )
-    strictness_group.add_argument(
-        "--enable-error-code",
-        metavar="NAME",
-        action="append",
-        default=[],
-        help="Enable a specific error code",
-    )
-
-    error_group = parser.add_argument_group(
-        title="Configuring error messages",
-        description="Adjust the amount of detail shown in error messages.",
-    )
-    add_invertible_flag(
-        "--show-error-context",
-        default=False,
-        dest="show_error_context",
-        help='Precede errors with "note:" messages explaining context',
-        group=error_group,
-    )
-    add_invertible_flag(
-        "--show-column-numbers",
-        default=False,
-        help="Show column numbers in error messages",
-        group=error_group,
-    )
-    add_invertible_flag(
-        "--show-error-end",
-        default=False,
-        help="Show end line/end column numbers in error messages."
-        " This implies --show-column-numbers",
-        group=error_group,
-    )
-    add_invertible_flag(
-        "--hide-error-codes",
-        default=False,
-        help="Hide error codes in error messages",
-        group=error_group,
-    )
-    add_invertible_flag(
-        "--show-error-code-links",
-        default=False,
-        help="Show links to error code documentation",
-        group=error_group,
-    )
-    add_invertible_flag(
-        "--pretty",
-        default=False,
-        help="Use visually nicer output in error messages:"
-        " Use soft word wrap, show source code snippets,"
-        " and show error location markers",
-        group=error_group,
-    )
-    add_invertible_flag(
-        "--no-color-output",
-        dest="color_output",
-        default=True,
-        help="Do not colorize error messages",
-        group=error_group,
-    )
-    add_invertible_flag(
-        "--no-error-summary",
-        dest="error_summary",
-        default=True,
-        help="Do not show error stats summary",
-        group=error_group,
-    )
-    add_invertible_flag(
-        "--show-absolute-path",
-        default=False,
-        help="Show absolute paths to files",
-        group=error_group,
-    )
-    error_group.add_argument(
-        "--soft-error-limit",
-        default=defaults.MANY_ERRORS_THRESHOLD,
-        type=int,
-        dest="many_errors_threshold",
-        help=argparse.SUPPRESS,
-    )
-
-    incremental_group = parser.add_argument_group(
-        title="Incremental mode",
-        description="Adjust how mypy incrementally type checks and caches modules. "
-        "Mypy caches type information about modules into a cache to "
-        "let you speed up future invocations of mypy. Also see "
-        "mypy's daemon mode: "
-        "mypy.readthedocs.io/en/stable/mypy_daemon.html#mypy-daemon",
-    )
-    incremental_group.add_argument(
-        "-i", "--incremental", action="store_true", help=argparse.SUPPRESS
-    )
-    incremental_group.add_argument(
-        "--no-incremental",
-        action="store_false",
-        dest="incremental",
-        help="Disable module cache (inverse: --incremental)",
-    )
-    incremental_group.add_argument(
-        "--cache-dir",
-        action="store",
-        metavar="DIR",
-        help="Store module cache info in the given folder in incremental mode "
-        "(defaults to '{}')".format(defaults.CACHE_DIR),
-    )
-    add_invertible_flag(
-        "--sqlite-cache",
-        default=False,
-        help="Use a sqlite database to store the cache",
-        group=incremental_group,
-    )
-    incremental_group.add_argument(
-        "--cache-fine-grained",
-        action="store_true",
-        help="Include fine-grained dependency information in the cache for the mypy daemon",
-    )
-    incremental_group.add_argument(
-        "--skip-version-check",
-        action="store_true",
-        help="Allow using cache written by older mypy version",
-    )
-    incremental_group.add_argument(
-        "--skip-cache-mtime-checks",
-        action="store_true",
-        help="Skip cache internal consistency checks based on mtime",
-    )
-
-    internals_group = parser.add_argument_group(
-        title="Advanced options", description="Debug and customize mypy internals."
-    )
-    internals_group.add_argument("--pdb", action="store_true", help="Invoke pdb on fatal error")
-    internals_group.add_argument(
-        "--show-traceback", "--tb", action="store_true", help="Show traceback on fatal error"
-    )
-    internals_group.add_argument(
-        "--raise-exceptions", action="store_true", help="Raise exception on fatal error"
-    )
-    internals_group.add_argument(
-        "--custom-typing-module",
-        metavar="MODULE",
-        dest="custom_typing_module",
-        help="Use a custom typing module",
-    )
-    internals_group.add_argument(
-        "--old-type-inference",
-        action="store_true",
-        help="Disable new experimental type inference algorithm",
-    )
-    # Deprecated reverse variant of the above.
-    internals_group.add_argument(
-        "--new-type-inference", action="store_true", help=argparse.SUPPRESS
-    )
-    parser.add_argument(
-        "--enable-incomplete-feature",
-        action="append",
-        metavar="{" + ",".join(sorted(INCOMPLETE_FEATURES)) + "}",
-        help="Enable support of incomplete/experimental features for early preview",
-    )
-    internals_group.add_argument(
-        "--custom-typeshed-dir", metavar="DIR", help="Use the custom typeshed in DIR"
-    )
-    add_invertible_flag(
-        "--warn-incomplete-stub",
-        default=False,
-        help="Warn if missing type annotation in typeshed, only relevant with"
-        " --disallow-untyped-defs or --disallow-incomplete-defs enabled",
-        group=internals_group,
-    )
-    internals_group.add_argument(
-        "--shadow-file",
-        nargs=2,
-        metavar=("SOURCE_FILE", "SHADOW_FILE"),
-        dest="shadow_file",
-        action="append",
-        help="When encountering SOURCE_FILE, read and type check "
-        "the contents of SHADOW_FILE instead.",
-    )
-    internals_group.add_argument("--fast-exit", action="store_true", help=argparse.SUPPRESS)
-    internals_group.add_argument(
-        "--no-fast-exit", action="store_false", dest="fast_exit", help=argparse.SUPPRESS
-    )
-    # This flag is useful for mypy tests, where function bodies may be omitted. Plugin developers
-    # may want to use this as well in their tests.
-    add_invertible_flag(
-        "--allow-empty-bodies", default=False, help=argparse.SUPPRESS, group=internals_group
-    )
-    # This undocumented feature exports limited line-level dependency information.
-    internals_group.add_argument("--export-ref-info", action="store_true", help=argparse.SUPPRESS)
-
-    report_group = parser.add_argument_group(
-        title="Report generation", description="Generate a report in the specified format."
-    )
-    for report_type in sorted(defaults.REPORTER_NAMES):
-        if report_type not in {"memory-xml"}:
-            report_group.add_argument(
-                f"--{report_type.replace('_', '-')}-report",
-                metavar="DIR",
-                dest=f"special-opts:{report_type}_report",
-            )
-
-    other_group = parser.add_argument_group(title="Miscellaneous")
-    other_group.add_argument("--quickstart-file", help=argparse.SUPPRESS)
-    other_group.add_argument("--junit-xml", help="Write junit.xml to the given file")
-    imports_group.add_argument(
-        "--junit-format",
-        choices=["global", "per_file"],
-        default="global",
-        help="If --junit-xml is set, specifies format. global: single test with all errors; per_file: one test entry per file with failures",
-    )
-    other_group.add_argument(
-        "--find-occurrences",
-        metavar="CLASS.MEMBER",
-        dest="special-opts:find_occurrences",
-        help="Print out all usages of a class member (experimental)",
-    )
-    other_group.add_argument(
-        "--scripts-are-modules",
-        action="store_true",
-        help="Script x becomes module x instead of __main__",
-    )
-
-    add_invertible_flag(
-        "--install-types",
-        default=False,
-        strict_flag=False,
-        help="Install detected missing library stub packages using pip",
-        group=other_group,
-    )
-    add_invertible_flag(
-        "--non-interactive",
-        default=False,
-        strict_flag=False,
-        help=(
-            "Install stubs without asking for confirmation and hide "
-            + "errors, with --install-types"
-        ),
-        group=other_group,
-        inverse="--interactive",
-    )
-
-    if server_options:
-        # TODO: This flag is superfluous; remove after a short transition (2018-03-16)
-        other_group.add_argument(
-            "--experimental",
-            action="store_true",
-            dest="fine_grained_incremental",
-            help="Enable fine-grained incremental mode",
-        )
-        other_group.add_argument(
-            "--use-fine-grained-cache",
-            action="store_true",
-            help="Use the cache in fine-grained incremental mode",
-        )
-
-    # hidden options
-    parser.add_argument(
-        "--stats", action="store_true", dest="dump_type_stats", help=argparse.SUPPRESS
-    )
-    parser.add_argument(
-        "--inferstats", action="store_true", dest="dump_inference_stats", help=argparse.SUPPRESS
-    )
-    parser.add_argument("--dump-build-stats", action="store_true", help=argparse.SUPPRESS)
-    # Dump timing stats for each processed file into the given output file
-    parser.add_argument("--timing-stats", dest="timing_stats", help=argparse.SUPPRESS)
-    # Dump per line type checking timing stats for each processed file into the given
-    # output file. Only total time spent in each top level expression will be shown.
-    # Times are show in microseconds.
-    parser.add_argument(
-        "--line-checking-stats", dest="line_checking_stats", help=argparse.SUPPRESS
-    )
-    # --debug-cache will disable any cache-related compressions/optimizations,
-    # which will make the cache writing process output pretty-printed JSON (which
-    # is easier to debug).
-    parser.add_argument("--debug-cache", action="store_true", help=argparse.SUPPRESS)
-    # --dump-deps will dump all fine-grained dependencies to stdout
-    parser.add_argument("--dump-deps", action="store_true", help=argparse.SUPPRESS)
-    # --dump-graph will dump the contents of the graph of SCCs and exit.
-    parser.add_argument("--dump-graph", action="store_true", help=argparse.SUPPRESS)
-    # --semantic-analysis-only does exactly that.
-    parser.add_argument("--semantic-analysis-only", action="store_true", help=argparse.SUPPRESS)
-    # Some tests use this to tell mypy that we are running a test.
-    parser.add_argument("--test-env", action="store_true", help=argparse.SUPPRESS)
-    # --local-partial-types disallows partial types spanning module top level and a function
-    # (implicitly defined in fine-grained incremental mode)
-    parser.add_argument("--local-partial-types", action="store_true", help=argparse.SUPPRESS)
-    # --logical-deps adds some more dependencies that are not semantically needed, but
-    # may be helpful to determine relative importance of classes and functions for overall
-    # type precision in a code base. It also _removes_ some deps, so this flag should be never
-    # used except for generating code stats. This also automatically enables --cache-fine-grained.
-    # NOTE: This is an experimental option that may be modified or removed at any time.
-    parser.add_argument("--logical-deps", action="store_true", help=argparse.SUPPRESS)
-    # --bazel changes some behaviors for use with Bazel (https://bazel.build).
-    parser.add_argument("--bazel", action="store_true", help=argparse.SUPPRESS)
-    # --package-root adds a directory below which directories are considered
-    # packages even without __init__.py.  May be repeated.
-    parser.add_argument(
-        "--package-root", metavar="ROOT", action="append", default=[], help=argparse.SUPPRESS
-    )
-    # --cache-map FILE ... gives a mapping from source files to cache files.
-    # Each triple of arguments is a source file, a cache meta file, and a cache data file.
-    # Modules not mentioned in the file will go through cache_dir.
-    # Must be followed by another flag or by '--' (and then only file args may follow).
-    parser.add_argument(
-        "--cache-map", nargs="+", dest="special-opts:cache_map", help=argparse.SUPPRESS
-    )
-    # --debug-serialize will run tree.serialize() even if cache generation is disabled.
-    # Useful for mypy_primer to detect serialize errors earlier.
-    parser.add_argument("--debug-serialize", action="store_true", help=argparse.SUPPRESS)
-
-    parser.add_argument(
-        "--disable-bytearray-promotion", action="store_true", help=argparse.SUPPRESS
-    )
-    parser.add_argument(
-        "--disable-memoryview-promotion", action="store_true", help=argparse.SUPPRESS
-    )
-    # This flag is deprecated, it has been moved to --extra-checks
-    parser.add_argument("--strict-concatenate", action="store_true", help=argparse.SUPPRESS)
-
-    # options specifying code to check
-    code_group = parser.add_argument_group(
-        title="Running code",
-        description="Specify the code you want to type check. For more details, see "
-        "mypy.readthedocs.io/en/stable/running_mypy.html#running-mypy",
-    )
-    add_invertible_flag(
-        "--explicit-package-bases",
-        default=False,
-        help="Use current directory and MYPYPATH to determine module names of files passed",
-        group=code_group,
-    )
-    add_invertible_flag(
-        "--fast-module-lookup", default=False, help=argparse.SUPPRESS, group=code_group
-    )
-    code_group.add_argument(
-        "--exclude",
-        action="append",
-        metavar="PATTERN",
-        default=[],
-        help=(
-            "Regular expression to match file names, directory names or paths which mypy should "
-            "ignore while recursively discovering files to check, e.g. --exclude '/setup\\.py$'. "
-            "May be specified more than once, eg. --exclude a --exclude b"
-        ),
-    )
-    code_group.add_argument(
-        "-m",
-        "--module",
-        action="append",
-        metavar="MODULE",
-        default=[],
-        dest="special-opts:modules",
-        help="Type-check module; can repeat for more modules",
-    )
-    code_group.add_argument(
-        "-p",
-        "--package",
-        action="append",
-        metavar="PACKAGE",
-        default=[],
-        dest="special-opts:packages",
-        help="Type-check package recursively; can be repeated",
-    )
-    code_group.add_argument(
-        "-c",
-        "--command",
-        action="append",
-        metavar="PROGRAM_TEXT",
-        dest="special-opts:command",
-        help="Type-check program passed in as string",
-    )
-    code_group.add_argument(
-        metavar="files",
-        nargs="*",
-        dest="special-opts:files",
-        help="Type-check given files or directories",
-    )
-
-    # Parse arguments once into a dummy namespace so we can get the
-    # filename for the config file and know if the user requested all strict options.
-    dummy = argparse.Namespace()
-    parser.parse_args(args, dummy)
-    config_file = dummy.config_file
-    # Don't explicitly test if "config_file is not None" for this check.
-    # This lets `--config-file=` (an empty string) be used to disable all config files.
-    if config_file and not os.path.exists(config_file):
-        parser.error(f"Cannot find config file '{config_file}'")
-
-    options = Options()
-    strict_option_set = False
-
-    def set_strict_flags() -> None:
-        nonlocal strict_option_set
-        strict_option_set = True
-        for dest, value in strict_flag_assignments:
-            setattr(options, dest, value)
-
-    # Parse config file first, so command line can override.
-    parse_config_file(options, set_strict_flags, config_file, stdout, stderr)
-
-    # Set strict flags before parsing (if strict mode enabled), so other command
-    # line options can override.
-    if getattr(dummy, "special-opts:strict"):
-        set_strict_flags()
-
-    # Override cache_dir if provided in the environment
-    environ_cache_dir = os.getenv("MYPY_CACHE_DIR", "")
-    if environ_cache_dir.strip():
-        options.cache_dir = environ_cache_dir
-    options.cache_dir = os.path.expanduser(options.cache_dir)
-
-    # Parse command line for real, using a split namespace.
-    special_opts = argparse.Namespace()
-    parser.parse_args(args, SplitNamespace(options, special_opts, "special-opts:"))
-
-    # The python_version is either the default, which can be overridden via a config file,
-    # or stored in special_opts and is passed via the command line.
-    options.python_version = special_opts.python_version or options.python_version
-    if options.python_version < (3,):
-        parser.error(
-            "Mypy no longer supports checking Python 2 code. "
-            "Consider pinning to mypy<0.980 if you need to check Python 2 code."
-        )
-    try:
-        infer_python_executable(options, special_opts)
-    except PythonExecutableInferenceError as e:
-        parser.error(str(e))
-
-    if special_opts.no_executable or options.no_site_packages:
-        options.python_executable = None
-
-    # Paths listed in the config file will be ignored if any paths, modules or packages
-    # are passed on the command line.
-    if not (special_opts.files or special_opts.packages or special_opts.modules):
-        if options.files:
-            special_opts.files = options.files
-        if options.packages:
-            special_opts.packages = options.packages
-        if options.modules:
-            special_opts.modules = options.modules
-
-    # Check for invalid argument combinations.
-    if require_targets:
-        code_methods = sum(
-            bool(c)
-            for c in [
-                special_opts.modules + special_opts.packages,
-                special_opts.command,
-                special_opts.files,
-            ]
-        )
-        if code_methods == 0 and not options.install_types:
-            parser.error("Missing target module, package, files, or command.")
-        elif code_methods > 1:
-            parser.error("May only specify one of: module/package, files, or command.")
-    if options.explicit_package_bases and not options.namespace_packages:
-        parser.error(
-            "Can only use --explicit-package-bases with --namespace-packages, since otherwise "
-            "examining __init__.py's is sufficient to determine module names for files"
-        )
-
-    # Check for overlapping `--always-true` and `--always-false` flags.
-    overlap = set(options.always_true) & set(options.always_false)
-    if overlap:
-        parser.error(
-            "You can't make a variable always true and always false (%s)"
-            % ", ".join(sorted(overlap))
-        )
-
-    validate_package_allow_list(options.untyped_calls_exclude)
-
-    # Process `--enable-error-code` and `--disable-error-code` flags
-    disabled_codes = set(options.disable_error_code)
-    enabled_codes = set(options.enable_error_code)
-
-    valid_error_codes = set(error_codes.keys())
-
-    invalid_codes = (enabled_codes | disabled_codes) - valid_error_codes
-    if invalid_codes:
-        parser.error(f"Invalid error code(s): {', '.join(sorted(invalid_codes))}")
-
-    options.disabled_error_codes |= {error_codes[code] for code in disabled_codes}
-    options.enabled_error_codes |= {error_codes[code] for code in enabled_codes}
-
-    # Enabling an error code always overrides disabling
-    options.disabled_error_codes -= options.enabled_error_codes
-
-    # Validate incomplete features.
-    for feature in options.enable_incomplete_feature:
-        if feature not in INCOMPLETE_FEATURES | COMPLETE_FEATURES:
-            parser.error(f"Unknown incomplete feature: {feature}")
-        if feature in COMPLETE_FEATURES:
-            print(f"Warning: {feature} is already enabled by default")
-
-    # Compute absolute path for custom typeshed (if present).
-    if options.custom_typeshed_dir is not None:
-        options.abs_custom_typeshed_dir = os.path.abspath(options.custom_typeshed_dir)
-
-    # Set build flags.
-    if special_opts.find_occurrences:
-        _find_occurrences = tuple(special_opts.find_occurrences.split("."))
-        if len(_find_occurrences) < 2:
-            parser.error("Can only find occurrences of class members.")
-        if len(_find_occurrences) != 2:
-            parser.error("Can only find occurrences of non-nested class members.")
-        state.find_occurrences = _find_occurrences
-
-    # Set reports.
-    for flag, val in vars(special_opts).items():
-        if flag.endswith("_report") and val is not None:
-            report_type = flag[:-7].replace("_", "-")
-            report_dir = val
-            options.report_dirs[report_type] = report_dir
-
-    # Process --package-root.
-    if options.package_root:
-        process_package_roots(fscache, parser, options)
-
-    # Process --cache-map.
-    if special_opts.cache_map:
-        if options.sqlite_cache:
-            parser.error("--cache-map is incompatible with --sqlite-cache")
-
-        process_cache_map(parser, special_opts, options)
-
-    # An explicitly specified cache_fine_grained implies local_partial_types
-    # (because otherwise the cache is not compatible with dmypy)
-    if options.cache_fine_grained:
-        options.local_partial_types = True
-
-    #  Implicitly show column numbers if error location end is shown
-    if options.show_error_end:
-        options.show_column_numbers = True
-
-    # Let logical_deps imply cache_fine_grained (otherwise the former is useless).
-    if options.logical_deps:
-        options.cache_fine_grained = True
-
-    if options.new_type_inference:
-        print(
-            "Warning: --new-type-inference flag is deprecated;"
-            " new type inference algorithm is already enabled by default"
-        )
-
-    if options.strict_concatenate and not strict_option_set:
-        print("Warning: --strict-concatenate is deprecated; use --extra-checks instead")
-
-    # Set target.
-    if special_opts.modules + special_opts.packages:
-        options.build_type = BuildType.MODULE
-        sys_path, _ = get_search_dirs(options.python_executable)
-        search_paths = SearchPaths(
-            (os.getcwd(),), tuple(mypy_path() + options.mypy_path), tuple(sys_path), ()
-        )
-        targets = []
-        # TODO: use the same cache that the BuildManager will
-        cache = FindModuleCache(search_paths, fscache, options)
-        for p in special_opts.packages:
-            if os.sep in p or os.altsep and os.altsep in p:
-                fail(f"Package name '{p}' cannot have a slash in it.", stderr, options)
-            p_targets = cache.find_modules_recursive(p)
-            if not p_targets:
-                fail(f"Can't find package '{p}'", stderr, options)
-            targets.extend(p_targets)
-        for m in special_opts.modules:
-            targets.append(BuildSource(None, m, None))
-        return targets, options
-    elif special_opts.command:
-        options.build_type = BuildType.PROGRAM_TEXT
-        targets = [BuildSource(None, None, "\n".join(special_opts.command))]
-        return targets, options
-    else:
-        try:
-            targets = create_source_list(special_opts.files, options, fscache)
-        # Variable named e2 instead of e to work around mypyc bug #620
-        # which causes issues when using the same variable to catch
-        # exceptions of different types.
-        except InvalidSourceList as e2:
-            fail(str(e2), stderr, options)
-        return targets, options
-
-
-def process_package_roots(
-    fscache: FileSystemCache | None, parser: argparse.ArgumentParser, options: Options
-) -> None:
-    """Validate and normalize package_root."""
-    if fscache is None:
-        parser.error("--package-root does not work here (no fscache)")
-    assert fscache is not None  # Since mypy doesn't know parser.error() raises.
-    # Do some stuff with drive letters to make Windows happy (esp. tests).
-    current_drive, _ = os.path.splitdrive(os.getcwd())
-    dot = os.curdir
-    dotslash = os.curdir + os.sep
-    dotdotslash = os.pardir + os.sep
-    trivial_paths = {dot, dotslash}
-    package_root = []
-    for root in options.package_root:
-        if os.path.isabs(root):
-            parser.error(f"Package root cannot be absolute: {root!r}")
-        drive, root = os.path.splitdrive(root)
-        if drive and drive != current_drive:
-            parser.error(f"Package root must be on current drive: {drive + root!r}")
-        # Empty package root is always okay.
-        if root:
-            root = os.path.relpath(root)  # Normalize the heck out of it.
-            if not root.endswith(os.sep):
-                root = root + os.sep
-            if root.startswith(dotdotslash):
-                parser.error(f"Package root cannot be above current directory: {root!r}")
-            if root in trivial_paths:
-                root = ""
-        package_root.append(root)
-    options.package_root = package_root
-    # Pass the package root on the the filesystem cache.
-    fscache.set_package_root(package_root)
-
-
-def process_cache_map(
-    parser: argparse.ArgumentParser, special_opts: argparse.Namespace, options: Options
-) -> None:
-    """Validate cache_map and copy into options.cache_map."""
-    n = len(special_opts.cache_map)
-    if n % 3 != 0:
-        parser.error("--cache-map requires one or more triples (see source)")
-    for i in range(0, n, 3):
-        source, meta_file, data_file = special_opts.cache_map[i : i + 3]
-        if source in options.cache_map:
-            parser.error(f"Duplicate --cache-map source {source})")
-        if not source.endswith(".py") and not source.endswith(".pyi"):
-            parser.error(f"Invalid --cache-map source {source} (triple[0] must be *.py[i])")
-        if not meta_file.endswith(".meta.json"):
-            parser.error(
-                "Invalid --cache-map meta_file %s (triple[1] must be *.meta.json)" % meta_file
-            )
-        if not data_file.endswith(".data.json"):
-            parser.error(
-                "Invalid --cache-map data_file %s (triple[2] must be *.data.json)" % data_file
-            )
-        options.cache_map[source] = (meta_file, data_file)
-
-
-def maybe_write_junit_xml(
-    td: float,
-    serious: bool,
-    all_messages: list[str],
-    messages_by_file: dict[str | None, list[str]],
-    options: Options,
-) -> None:
-    if options.junit_xml:
-        py_version = f"{options.python_version[0]}_{options.python_version[1]}"
-        if options.junit_format == "global":
-            util.write_junit_xml(
-                td,
-                serious,
-                {None: all_messages} if all_messages else {},
-                options.junit_xml,
-                py_version,
-                options.platform,
-            )
-        else:
-            # per_file
-            util.write_junit_xml(
-                td, serious, messages_by_file, options.junit_xml, py_version, options.platform
-            )
-
-
-def fail(msg: str, stderr: TextIO, options: Options) -> NoReturn:
-    """Fail with a serious error."""
-    stderr.write(f"{msg}\n")
-    maybe_write_junit_xml(
-        0.0, serious=True, all_messages=[msg], messages_by_file={None: [msg]}, options=options
-    )
-    sys.exit(2)
-
-
-def read_types_packages_to_install(cache_dir: str, after_run: bool) -> list[str]:
-    if not os.path.isdir(cache_dir):
-        if not after_run:
-            sys.stderr.write(
-                "error: Can't determine which types to install with no files to check "
-                + "(and no cache from previous mypy run)\n"
-            )
-        else:
-            sys.stderr.write("error: --install-types failed (no mypy cache directory)\n")
-        sys.exit(2)
-    fnam = build.missing_stubs_file(cache_dir)
-    if not os.path.isfile(fnam):
-        # No missing stubs.
-        return []
-    with open(fnam) as f:
-        return [line.strip() for line in f]
-
-
-def install_types(
-    formatter: util.FancyFormatter,
-    options: Options,
-    *,
-    after_run: bool = False,
-    non_interactive: bool = False,
-) -> bool:
-    """Install stub packages using pip if some missing stubs were detected."""
-    packages = read_types_packages_to_install(options.cache_dir, after_run)
-    if not packages:
-        # If there are no missing stubs, generate no output.
-        return False
-    if after_run and not non_interactive:
-        print()
-    print("Installing missing stub packages:")
-    assert options.python_executable, "Python executable required to install types"
-    cmd = [options.python_executable, "-m", "pip", "install"] + packages
-    print(formatter.style(" ".join(cmd), "none", bold=True))
-    print()
-    if not non_interactive:
-        x = input("Install? [yN] ")
-        if not x.strip() or not x.lower().startswith("y"):
-            print(formatter.style("mypy: Skipping installation", "red", bold=True))
-            sys.exit(2)
-        print()
-    subprocess.run(cmd)
-    return True