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

jaclang/vendor/mypy/plugins/singledispatch.py

@@ -1,224 +0,0 @@
-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

jaclang/vendor/mypy/py.typed

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

jaclang/vendor/mypy/pyinfo.py

@@ -1,78 +0,0 @@
-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)

jaclang/vendor/mypy/reachability.py

@@ -1,362 +0,0 @@
-"""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