class Proto[T](Protocol):
    @type_check_only
    def proto(self, _: T, /) -> None: ...

type One = Literal[1]
type Two = Literal[2]

@final
class Impl[N: int]:
    # ensure `N` is invariant
    def __init__(self, n: N, /) -> None: ...
    @type_check_only
    def get_n(self, /) -> N: ...

    # implement Proto[N] for Impl[N] and Proto[M] for Impl[One] (for all integers N, M)
    @overload
    def proto(self, _: "Impl[N]", /) -> None: ...
    @overload
    def proto[M: int](self: "Impl[One]", _: "Impl[M]", /) -> None: ...

class check1[T]:
    def __init__(self, x: Proto[T], /) -> None: ...

# Here it all works as expected
impl1 = Impl[One](1)
impl2 = Impl[Two](2)
impl_ = Impl[int](3)
_ = check1[Impl[One]](impl1)  # ok (first overload applies)
_ = check1[Impl[Two]](impl1)  # ok (second overload applies)
_ = check1[Impl[One]](impl2)  # error (second overload doesn't apply because One != Two)
_ = check1[Impl[Two]](impl2)  # ok (first overload applies)
_ = check1[Impl[One]](impl_)  # error (second overload doesn't apply because N is invariant)
_ = check1[Impl[Two]](impl_)  # error (second overload doesn't apply because N is invariant)
_ = check1[Impl[int]](impl_)  # ok (first overload applies)

class func[T]:
    @overload
    def __init__(self, x: T, y: Proto[T], /) -> None: ...
    @overload
    def __init__(self, x: Proto[T], y: T, /) -> None: ...
	# implementation not important

_ = func[Impl[One]](impl2, impl1)  # error (correct)
_ = func[Impl[One]](impl1, impl2)  # error (correct)
_ = func[Impl[int]](impl_, impl1)  # ok
_ = func[Impl[int]](impl1, impl_)  # ok
_ = func[Impl[Two]](impl2, impl1)  # ok
_ = func[Impl[Two]](impl1, impl2)  # ok
reveal_type(func(impl2, impl1))  # ok, type is `func[Impl[Two]]`
reveal_type(func(impl1, impl2))  # error, but why?