mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/plugins/singledispatch.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+from typing import Final, NamedTuple, Sequence, TypeVar, Union
+from typing_extensions import TypeAlias as _TypeAlias
+
+from mypy.messages import format_type
+from mypy.nodes import ARG_POS, Argument, Block, ClassDef, Context, SymbolTable, TypeInfo, Var
+from mypy.options import Options
+from mypy.plugin import CheckerPluginInterface, FunctionContext, MethodContext, MethodSigContext
+from mypy.plugins.common import add_method_to_class
+from mypy.subtypes import is_subtype
+from mypy.types import (
+    AnyType,
+    CallableType,
+    FunctionLike,
+    Instance,
+    NoneType,
+    Overloaded,
+    Type,
+    TypeOfAny,
+    get_proper_type,
+)
+
+
+class SingledispatchTypeVars(NamedTuple):
+    return_type: Type
+    fallback: CallableType
+
+
+class RegisterCallableInfo(NamedTuple):
+    register_type: Type
+    singledispatch_obj: Instance
+
+
+SINGLEDISPATCH_TYPE: Final = "functools._SingleDispatchCallable"
+
+SINGLEDISPATCH_REGISTER_METHOD: Final = f"{SINGLEDISPATCH_TYPE}.register"
+
+SINGLEDISPATCH_CALLABLE_CALL_METHOD: Final = f"{SINGLEDISPATCH_TYPE}.__call__"
+
+
+def get_singledispatch_info(typ: Instance) -> SingledispatchTypeVars | None:
+    if len(typ.args) == 2:
+        return SingledispatchTypeVars(*typ.args)  # type: ignore[arg-type]
+    return None
+
+
+T = TypeVar("T")
+
+
+def get_first_arg(args: list[list[T]]) -> T | None:
+    """Get the element that corresponds to the first argument passed to the function"""
+    if args and args[0]:
+        return args[0][0]
+    return None
+
+
+REGISTER_RETURN_CLASS: Final = "_SingleDispatchRegisterCallable"
+
+REGISTER_CALLABLE_CALL_METHOD: Final = f"functools.{REGISTER_RETURN_CLASS}.__call__"
+
+
+def make_fake_register_class_instance(
+    api: CheckerPluginInterface, type_args: Sequence[Type]
+) -> Instance:
+    defn = ClassDef(REGISTER_RETURN_CLASS, Block([]))
+    defn.fullname = f"functools.{REGISTER_RETURN_CLASS}"
+    info = TypeInfo(SymbolTable(), defn, "functools")
+    obj_type = api.named_generic_type("builtins.object", []).type
+    info.bases = [Instance(obj_type, [])]
+    info.mro = [info, obj_type]
+    defn.info = info
+
+    func_arg = Argument(Var("name"), AnyType(TypeOfAny.implementation_artifact), None, ARG_POS)
+    add_method_to_class(api, defn, "__call__", [func_arg], NoneType())
+
+    return Instance(info, type_args)
+
+
+PluginContext: _TypeAlias = Union[FunctionContext, MethodContext]
+
+
+def fail(ctx: PluginContext, msg: str, context: Context | None) -> None:
+    """Emit an error message.
+
+    This tries to emit an error message at the location specified by `context`, falling back to the
+    location specified by `ctx.context`. This is helpful when the only context information about
+    where you want to put the error message may be None (like it is for `CallableType.definition`)
+    and falling back to the location of the calling function is fine."""
+    # TODO: figure out if there is some more reliable way of getting context information, so this
+    # function isn't necessary
+    if context is not None:
+        err_context = context
+    else:
+        err_context = ctx.context
+    ctx.api.fail(msg, err_context)
+
+
+def create_singledispatch_function_callback(ctx: FunctionContext) -> Type:
+    """Called for functools.singledispatch"""
+    func_type = get_proper_type(get_first_arg(ctx.arg_types))
+    if isinstance(func_type, CallableType):
+        if len(func_type.arg_kinds) < 1:
+            fail(
+                ctx, "Singledispatch function requires at least one argument", func_type.definition
+            )
+            return ctx.default_return_type
+
+        elif not func_type.arg_kinds[0].is_positional(star=True):
+            fail(
+                ctx,
+                "First argument to singledispatch function must be a positional argument",
+                func_type.definition,
+            )
+            return ctx.default_return_type
+
+        # singledispatch returns an instance of functools._SingleDispatchCallable according to
+        # typeshed
+        singledispatch_obj = get_proper_type(ctx.default_return_type)
+        assert isinstance(singledispatch_obj, Instance)
+        singledispatch_obj.args += (func_type,)
+
+    return ctx.default_return_type
+
+
+def singledispatch_register_callback(ctx: MethodContext) -> Type:
+    """Called for functools._SingleDispatchCallable.register"""
+    assert isinstance(ctx.type, Instance)
+    # TODO: check that there's only one argument
+    first_arg_type = get_proper_type(get_first_arg(ctx.arg_types))
+    if isinstance(first_arg_type, (CallableType, Overloaded)) and first_arg_type.is_type_obj():
+        # HACK: We received a class as an argument to register. We need to be able
+        # to access the function that register is being applied to, and the typeshed definition
+        # of register has it return a generic Callable, so we create a new
+        # SingleDispatchRegisterCallable class, define a __call__ method, and then add a
+        # plugin hook for that.
+
+        # is_subtype doesn't work when the right type is Overloaded, so we need the
+        # actual type
+        register_type = first_arg_type.items[0].ret_type
+        type_args = RegisterCallableInfo(register_type, ctx.type)
+        register_callable = make_fake_register_class_instance(ctx.api, type_args)
+        return register_callable
+    elif isinstance(first_arg_type, CallableType):
+        # TODO: do more checking for registered functions
+        register_function(ctx, ctx.type, first_arg_type, ctx.api.options)
+        # The typeshed stubs for register say that the function returned is Callable[..., T], even
+        # though the function returned is the same as the one passed in. We return the type of the
+        # function so that mypy can properly type check cases where the registered function is used
+        # directly (instead of through singledispatch)
+        return first_arg_type
+
+    # fallback in case we don't recognize the arguments
+    return ctx.default_return_type
+
+
+def register_function(
+    ctx: PluginContext,
+    singledispatch_obj: Instance,
+    func: Type,
+    options: Options,
+    register_arg: Type | None = None,
+) -> None:
+    """Register a function"""
+
+    func = get_proper_type(func)
+    if not isinstance(func, CallableType):
+        return
+    metadata = get_singledispatch_info(singledispatch_obj)
+    if metadata is None:
+        # if we never added the fallback to the type variables, we already reported an error, so
+        # just don't do anything here
+        return
+    dispatch_type = get_dispatch_type(func, register_arg)
+    if dispatch_type is None:
+        # TODO: report an error here that singledispatch requires at least one argument
+        # (might want to do the error reporting in get_dispatch_type)
+        return
+    fallback = metadata.fallback
+
+    fallback_dispatch_type = fallback.arg_types[0]
+    if not is_subtype(dispatch_type, fallback_dispatch_type):
+        fail(
+            ctx,
+            "Dispatch type {} must be subtype of fallback function first argument {}".format(
+                format_type(dispatch_type, options), format_type(fallback_dispatch_type, options)
+            ),
+            func.definition,
+        )
+        return
+    return
+
+
+def get_dispatch_type(func: CallableType, register_arg: Type | None) -> Type | None:
+    if register_arg is not None:
+        return register_arg
+    if func.arg_types:
+        return func.arg_types[0]
+    return None
+
+
+def call_singledispatch_function_after_register_argument(ctx: MethodContext) -> Type:
+    """Called on the function after passing a type to register"""
+    register_callable = ctx.type
+    if isinstance(register_callable, Instance):
+        type_args = RegisterCallableInfo(*register_callable.args)  # type: ignore[arg-type]
+        func = get_first_arg(ctx.arg_types)
+        if func is not None:
+            register_function(
+                ctx, type_args.singledispatch_obj, func, ctx.api.options, type_args.register_type
+            )
+            # see call to register_function in the callback for register
+            return func
+    return ctx.default_return_type
+
+
+def call_singledispatch_function_callback(ctx: MethodSigContext) -> FunctionLike:
+    """Called for functools._SingleDispatchCallable.__call__"""
+    if not isinstance(ctx.type, Instance):
+        return ctx.default_signature
+    metadata = get_singledispatch_info(ctx.type)
+    if metadata is None:
+        return ctx.default_signature
+    return metadata.fallback

mypy/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561.  The mypy package uses inline types.

mypy/pyinfo.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+"""Utilities to find the site and prefix information of a Python executable.
+
+This file MUST remain compatible with all Python 3.8+ versions. Since we cannot make any
+assumptions about the Python being executed, this module should not use *any* dependencies outside
+of the standard library found in Python 3.8. This file is run each mypy run, so it should be kept
+as fast as possible.
+"""
+import sys
+
+if __name__ == "__main__":
+    # HACK: We don't want to pick up mypy.types as the top-level types
+    #       module. This could happen if this file is run as a script.
+    #       This workaround fixes this for Python versions before 3.11.
+    if sys.version_info < (3, 11):
+        old_sys_path = sys.path
+        sys.path = sys.path[1:]
+        import types  # noqa: F401
+
+        sys.path = old_sys_path
+
+import os
+import site
+import sysconfig
+
+
+def getsitepackages() -> list[str]:
+    res = []
+    if hasattr(site, "getsitepackages"):
+        res.extend(site.getsitepackages())
+
+        if hasattr(site, "getusersitepackages") and site.ENABLE_USER_SITE:
+            res.insert(0, site.getusersitepackages())
+    else:
+        res = [sysconfig.get_paths()["purelib"]]
+    return res
+
+
+def getsyspath() -> list[str]:
+    # Do not include things from the standard library
+    # because those should come from typeshed.
+    stdlib_zip = os.path.join(
+        sys.base_exec_prefix,
+        getattr(sys, "platlibdir", "lib"),
+        f"python{sys.version_info.major}{sys.version_info.minor}.zip",
+    )
+    stdlib = sysconfig.get_path("stdlib")
+    stdlib_ext = os.path.join(stdlib, "lib-dynload")
+    excludes = {stdlib_zip, stdlib, stdlib_ext}
+
+    # Drop the first entry of sys.path
+    # - If pyinfo.py is executed as a script (in a subprocess), this is the directory
+    #   containing pyinfo.py
+    # - Otherwise, if mypy launched via console script, this is the directory of the script
+    # - Otherwise, if mypy launched via python -m mypy, this is the current directory
+    # In all these cases, it is desirable to drop the first entry
+    # Note that mypy adds the cwd to SearchPaths.python_path, so we still find things on the
+    # cwd consistently (the return value here sets SearchPaths.package_path)
+
+    # Python 3.11 adds a "safe_path" flag wherein Python won't automatically prepend
+    # anything to sys.path. In this case, the first entry of sys.path is no longer special.
+    offset = 0 if sys.version_info >= (3, 11) and sys.flags.safe_path else 1
+
+    abs_sys_path = (os.path.abspath(p) for p in sys.path[offset:])
+    return [p for p in abs_sys_path if p not in excludes]
+
+
+def getsearchdirs() -> tuple[list[str], list[str]]:
+    return (getsyspath(), getsitepackages())
+
+
+if __name__ == "__main__":
+    if sys.argv[-1] == "getsearchdirs":
+        print(repr(getsearchdirs()))
+    else:
+        print("ERROR: incorrect argument to pyinfo.py.", file=sys.stderr)
+        sys.exit(1)

mypy/reachability.py

@@ -0,0 +1,362 @@
+"""Utilities related to determining the reachability of code (in semantic analysis)."""
+
+from __future__ import annotations
+
+from typing import Final, Tuple, TypeVar
+
+from mypy.literals import literal
+from mypy.nodes import (
+    LITERAL_YES,
+    AssertStmt,
+    Block,
+    CallExpr,
+    ComparisonExpr,
+    Expression,
+    FuncDef,
+    IfStmt,
+    Import,
+    ImportAll,
+    ImportFrom,
+    IndexExpr,
+    IntExpr,
+    MatchStmt,
+    MemberExpr,
+    NameExpr,
+    OpExpr,
+    SliceExpr,
+    StrExpr,
+    TupleExpr,
+    UnaryExpr,
+)
+from mypy.options import Options
+from mypy.patterns import AsPattern, OrPattern, Pattern
+from mypy.traverser import TraverserVisitor
+
+# Inferred truth value of an expression.
+ALWAYS_TRUE: Final = 1
+MYPY_TRUE: Final = 2  # True in mypy, False at runtime
+ALWAYS_FALSE: Final = 3
+MYPY_FALSE: Final = 4  # False in mypy, True at runtime
+TRUTH_VALUE_UNKNOWN: Final = 5
+
+inverted_truth_mapping: Final = {
+    ALWAYS_TRUE: ALWAYS_FALSE,
+    ALWAYS_FALSE: ALWAYS_TRUE,
+    TRUTH_VALUE_UNKNOWN: TRUTH_VALUE_UNKNOWN,
+    MYPY_TRUE: MYPY_FALSE,
+    MYPY_FALSE: MYPY_TRUE,
+}
+
+reverse_op: Final = {"==": "==", "!=": "!=", "<": ">", ">": "<", "<=": ">=", ">=": "<="}
+
+
+def infer_reachability_of_if_statement(s: IfStmt, options: Options) -> None:
+    for i in range(len(s.expr)):
+        result = infer_condition_value(s.expr[i], options)
+        if result in (ALWAYS_FALSE, MYPY_FALSE):
+            # The condition is considered always false, so we skip the if/elif body.
+            mark_block_unreachable(s.body[i])
+        elif result in (ALWAYS_TRUE, MYPY_TRUE):
+            # This condition is considered always true, so all of the remaining
+            # elif/else bodies should not be checked.
+            if result == MYPY_TRUE:
+                # This condition is false at runtime; this will affect
+                # import priorities.
+                mark_block_mypy_only(s.body[i])
+            for body in s.body[i + 1 :]:
+                mark_block_unreachable(body)
+
+            # Make sure else body always exists and is marked as
+            # unreachable so the type checker always knows that
+            # all control flow paths will flow through the if
+            # statement body.
+            if not s.else_body:
+                s.else_body = Block([])
+            mark_block_unreachable(s.else_body)
+            break
+
+
+def infer_reachability_of_match_statement(s: MatchStmt, options: Options) -> None:
+    for i, guard in enumerate(s.guards):
+        pattern_value = infer_pattern_value(s.patterns[i])
+
+        if guard is not None:
+            guard_value = infer_condition_value(guard, options)
+        else:
+            guard_value = ALWAYS_TRUE
+
+        if pattern_value in (ALWAYS_FALSE, MYPY_FALSE) or guard_value in (
+            ALWAYS_FALSE,
+            MYPY_FALSE,
+        ):
+            # The case is considered always false, so we skip the case body.
+            mark_block_unreachable(s.bodies[i])
+        elif pattern_value in (ALWAYS_FALSE, MYPY_TRUE) and guard_value in (
+            ALWAYS_TRUE,
+            MYPY_TRUE,
+        ):
+            for body in s.bodies[i + 1 :]:
+                mark_block_unreachable(body)
+
+        if guard_value == MYPY_TRUE:
+            # This condition is false at runtime; this will affect
+            # import priorities.
+            mark_block_mypy_only(s.bodies[i])
+
+
+def assert_will_always_fail(s: AssertStmt, options: Options) -> bool:
+    return infer_condition_value(s.expr, options) in (ALWAYS_FALSE, MYPY_FALSE)
+
+
+def infer_condition_value(expr: Expression, options: Options) -> int:
+    """Infer whether the given condition is always true/false.
+
+    Return ALWAYS_TRUE if always true, ALWAYS_FALSE if always false,
+    MYPY_TRUE if true under mypy and false at runtime, MYPY_FALSE if
+    false under mypy and true at runtime, else TRUTH_VALUE_UNKNOWN.
+    """
+    pyversion = options.python_version
+    name = ""
+    negated = False
+    alias = expr
+    if isinstance(alias, UnaryExpr):
+        if alias.op == "not":
+            expr = alias.expr
+            negated = True
+    result = TRUTH_VALUE_UNKNOWN
+    if isinstance(expr, NameExpr):
+        name = expr.name
+    elif isinstance(expr, MemberExpr):
+        name = expr.name
+    elif isinstance(expr, OpExpr) and expr.op in ("and", "or"):
+        left = infer_condition_value(expr.left, options)
+        if (left in (ALWAYS_TRUE, MYPY_TRUE) and expr.op == "and") or (
+            left in (ALWAYS_FALSE, MYPY_FALSE) and expr.op == "or"
+        ):
+            # Either `True and <other>` or `False or <other>`: the result will
+            # always be the right-hand-side.
+            return infer_condition_value(expr.right, options)
+        else:
+            # The result will always be the left-hand-side (e.g. ALWAYS_* or
+            # TRUTH_VALUE_UNKNOWN).
+            return left
+    else:
+        result = consider_sys_version_info(expr, pyversion)
+        if result == TRUTH_VALUE_UNKNOWN:
+            result = consider_sys_platform(expr, options.platform)
+    if result == TRUTH_VALUE_UNKNOWN:
+        if name == "PY2":
+            result = ALWAYS_FALSE
+        elif name == "PY3":
+            result = ALWAYS_TRUE
+        elif name == "MYPY" or name == "TYPE_CHECKING":
+            result = MYPY_TRUE
+        elif name in options.always_true:
+            result = ALWAYS_TRUE
+        elif name in options.always_false:
+            result = ALWAYS_FALSE
+    if negated:
+        result = inverted_truth_mapping[result]
+    return result
+
+
+def infer_pattern_value(pattern: Pattern) -> int:
+    if isinstance(pattern, AsPattern) and pattern.pattern is None:
+        return ALWAYS_TRUE
+    elif isinstance(pattern, OrPattern) and any(
+        infer_pattern_value(p) == ALWAYS_TRUE for p in pattern.patterns
+    ):
+        return ALWAYS_TRUE
+    else:
+        return TRUTH_VALUE_UNKNOWN
+
+
+def consider_sys_version_info(expr: Expression, pyversion: tuple[int, ...]) -> int:
+    """Consider whether expr is a comparison involving sys.version_info.
+
+    Return ALWAYS_TRUE, ALWAYS_FALSE, or TRUTH_VALUE_UNKNOWN.
+    """
+    # Cases supported:
+    # - sys.version_info[<int>] <compare_op> <int>
+    # - sys.version_info[:<int>] <compare_op> <tuple_of_n_ints>
+    # - sys.version_info <compare_op> <tuple_of_1_or_2_ints>
+    #   (in this case <compare_op> must be >, >=, <, <=, but cannot be ==, !=)
+    if not isinstance(expr, ComparisonExpr):
+        return TRUTH_VALUE_UNKNOWN
+    # Let's not yet support chained comparisons.
+    if len(expr.operators) > 1:
+        return TRUTH_VALUE_UNKNOWN
+    op = expr.operators[0]
+    if op not in ("==", "!=", "<=", ">=", "<", ">"):
+        return TRUTH_VALUE_UNKNOWN
+
+    index = contains_sys_version_info(expr.operands[0])
+    thing = contains_int_or_tuple_of_ints(expr.operands[1])
+    if index is None or thing is None:
+        index = contains_sys_version_info(expr.operands[1])
+        thing = contains_int_or_tuple_of_ints(expr.operands[0])
+        op = reverse_op[op]
+    if isinstance(index, int) and isinstance(thing, int):
+        # sys.version_info[i] <compare_op> k
+        if 0 <= index <= 1:
+            return fixed_comparison(pyversion[index], op, thing)
+        else:
+            return TRUTH_VALUE_UNKNOWN
+    elif isinstance(index, tuple) and isinstance(thing, tuple):
+        lo, hi = index
+        if lo is None:
+            lo = 0
+        if hi is None:
+            hi = 2
+        if 0 <= lo < hi <= 2:
+            val = pyversion[lo:hi]
+            if len(val) == len(thing) or len(val) > len(thing) and op not in ("==", "!="):
+                return fixed_comparison(val, op, thing)
+    return TRUTH_VALUE_UNKNOWN
+
+
+def consider_sys_platform(expr: Expression, platform: str) -> int:
+    """Consider whether expr is a comparison involving sys.platform.
+
+    Return ALWAYS_TRUE, ALWAYS_FALSE, or TRUTH_VALUE_UNKNOWN.
+    """
+    # Cases supported:
+    # - sys.platform == 'posix'
+    # - sys.platform != 'win32'
+    # - sys.platform.startswith('win')
+    if isinstance(expr, ComparisonExpr):
+        # Let's not yet support chained comparisons.
+        if len(expr.operators) > 1:
+            return TRUTH_VALUE_UNKNOWN
+        op = expr.operators[0]
+        if op not in ("==", "!="):
+            return TRUTH_VALUE_UNKNOWN
+        if not is_sys_attr(expr.operands[0], "platform"):
+            return TRUTH_VALUE_UNKNOWN
+        right = expr.operands[1]
+        if not isinstance(right, StrExpr):
+            return TRUTH_VALUE_UNKNOWN
+        return fixed_comparison(platform, op, right.value)
+    elif isinstance(expr, CallExpr):
+        if not isinstance(expr.callee, MemberExpr):
+            return TRUTH_VALUE_UNKNOWN
+        if len(expr.args) != 1 or not isinstance(expr.args[0], StrExpr):
+            return TRUTH_VALUE_UNKNOWN
+        if not is_sys_attr(expr.callee.expr, "platform"):
+            return TRUTH_VALUE_UNKNOWN
+        if expr.callee.name != "startswith":
+            return TRUTH_VALUE_UNKNOWN
+        if platform.startswith(expr.args[0].value):
+            return ALWAYS_TRUE
+        else:
+            return ALWAYS_FALSE
+    else:
+        return TRUTH_VALUE_UNKNOWN
+
+
+Targ = TypeVar("Targ", int, str, Tuple[int, ...])
+
+
+def fixed_comparison(left: Targ, op: str, right: Targ) -> int:
+    rmap = {False: ALWAYS_FALSE, True: ALWAYS_TRUE}
+    if op == "==":
+        return rmap[left == right]
+    if op == "!=":
+        return rmap[left != right]
+    if op == "<=":
+        return rmap[left <= right]
+    if op == ">=":
+        return rmap[left >= right]
+    if op == "<":
+        return rmap[left < right]
+    if op == ">":
+        return rmap[left > right]
+    return TRUTH_VALUE_UNKNOWN
+
+
+def contains_int_or_tuple_of_ints(expr: Expression) -> None | int | tuple[int, ...]:
+    if isinstance(expr, IntExpr):
+        return expr.value
+    if isinstance(expr, TupleExpr):
+        if literal(expr) == LITERAL_YES:
+            thing = []
+            for x in expr.items:
+                if not isinstance(x, IntExpr):
+                    return None
+                thing.append(x.value)
+            return tuple(thing)
+    return None
+
+
+def contains_sys_version_info(expr: Expression) -> None | int | tuple[int | None, int | None]:
+    if is_sys_attr(expr, "version_info"):
+        return (None, None)  # Same as sys.version_info[:]
+    if isinstance(expr, IndexExpr) and is_sys_attr(expr.base, "version_info"):
+        index = expr.index
+        if isinstance(index, IntExpr):
+            return index.value
+        if isinstance(index, SliceExpr):
+            if index.stride is not None:
+                if not isinstance(index.stride, IntExpr) or index.stride.value != 1:
+                    return None
+            begin = end = None
+            if index.begin_index is not None:
+                if not isinstance(index.begin_index, IntExpr):
+                    return None
+                begin = index.begin_index.value
+            if index.end_index is not None:
+                if not isinstance(index.end_index, IntExpr):
+                    return None
+                end = index.end_index.value
+            return (begin, end)
+    return None
+
+
+def is_sys_attr(expr: Expression, name: str) -> bool:
+    # TODO: This currently doesn't work with code like this:
+    # - import sys as _sys
+    # - from sys import version_info
+    if isinstance(expr, MemberExpr) and expr.name == name:
+        if isinstance(expr.expr, NameExpr) and expr.expr.name == "sys":
+            # TODO: Guard against a local named sys, etc.
+            # (Though later passes will still do most checking.)
+            return True
+    return False
+
+
+def mark_block_unreachable(block: Block) -> None:
+    block.is_unreachable = True
+    block.accept(MarkImportsUnreachableVisitor())
+
+
+class MarkImportsUnreachableVisitor(TraverserVisitor):
+    """Visitor that flags all imports nested within a node as unreachable."""
+
+    def visit_import(self, node: Import) -> None:
+        node.is_unreachable = True
+
+    def visit_import_from(self, node: ImportFrom) -> None:
+        node.is_unreachable = True
+
+    def visit_import_all(self, node: ImportAll) -> None:
+        node.is_unreachable = True
+
+
+def mark_block_mypy_only(block: Block) -> None:
+    block.accept(MarkImportsMypyOnlyVisitor())
+
+
+class MarkImportsMypyOnlyVisitor(TraverserVisitor):
+    """Visitor that sets is_mypy_only (which affects priority)."""
+
+    def visit_import(self, node: Import) -> None:
+        node.is_mypy_only = True
+
+    def visit_import_from(self, node: ImportFrom) -> None:
+        node.is_mypy_only = True
+
+    def visit_import_all(self, node: ImportAll) -> None:
+        node.is_mypy_only = True
+
+    def visit_func_def(self, node: FuncDef) -> None:
+        node.is_mypy_only = True