coady__multimethod-26

The user is reporting a `TypeError` when using `type` or a metaclass as a type hint in a `@multimethod` decorated function.
The error occurs when calling `type.mro()`, which is an unbound method and needs an argument.

Looking at the traceback:
- `multimethod/__init__.py`, line 184, in `__call__`
- `multimethod/__init__.py`, line 174, in `__missing__`
- `multimethod/__init__.py`, line 17, in `groupby`
- `multimethod/__init__.py`, line 104, in `__sub__`
- `multimethod/__init__.py`, line 103, in `<genexpr>`: `mros = (subclass.mro() for subclass in self)`

The problem is `subclass.mro()`. If `subclass` is `type`, `type.mro()` is called, which is an unbound method of the `type` metaclass.
Normally, for a class `C`, `C.mro()` works because it's a method of `type` called on the instance `C`.
But if `C` is `type` itself, `type.mro()` is called as an unbound method.

Wait, if `subclass` is `type`, then `type.mro()` should be called as `type.mro(type)`.

Let's start by reproducing the issue.

{
  "command": "python3 - <<'PY'\nfrom multimethod import multimethod\n\n@multimethod\ndef f(x: type):\n    print(\"success\")\n\ntry:\n    f(int)\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "success\n",
  "stderr": "",
  "exit_code": 0
}

Wait, it succeeded?
"success" was printed.
Let me re-read the problem statement.
Example:
```python
@multimethod
def f(x: type):
    print("success")

f(int)
```
Expected: success. Actual: TypeError.

My reproduction:
```python
from multimethod import multimethod

@multimethod
def f(x: type):
    print("success")

f(int)
```
Output: `success`.

Why did it work for me? Let me check the environment.
Maybe the version of `multimethod` I have is different or the Python version is different.
The traceback provided in the issue:
```
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 174, in __missing__
    groups = groupby(signature(types).__sub__, self.parents(types))
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 17, in groupby
    groups[func(value)].append(value)
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 104, in __sub__
    return tuple(mro.index(cls if cls in mro else object) for mro, cls in zip(mros, other))
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 104, in <genexpr>
    return tuple(mro.index(cls if cls in mro else object) for mro, cls in zip(mros, other))
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 103, in <genexpr>
    mros = (subclass.mro() for subclass in self)
TypeError: unbound method type.mro() needs an argument
```

Wait, I might have just called it with `int`. `int` is a class.
If I define `@multimethod def f(x: type): ...`, and I call `f(int)`, `int` is a type.
The traceback says the error happens in `__sub__` within `__missing__`.
`__missing__` is called when the exact type signature is not found.
In my case:
`f(x: type)` is defined.
`f(int)` is called.
`int` is an instance of `type`.
So `@multimethod` might have found the match immediately?

Wait, if I have:
```python
@multimethod
def f(x: int):
    print("int")

@multimethod
def f(x: type):
    print("type")
```
And call `f(int)`.
`int` is not an `int` (it's a class), but it is a `type`.
So it should call the second one.

Let's try a case where it actually goes to `__missing__`.
Actually, the example provided in the issue is:
```python
@multimethod
def f(x: type):
    print("success")

f(int)
```
Why would this trigger `__missing__`?
Maybe if there is no exact match?
But `type` is the type of `int`.

Wait, let me check the `multimethod` implementation of `__call__` and how it handles dispatch.
The traceback says:
`return self[tuple(map(self.get_type, args))](*args, **kwargs)`
`self` is the `Multimethod` object. `self[...]` calls `__getitem__`.
If `__getitem__` doesn't find the key, it might call `__missing__` (if it's a `dict` subclass or similar).

Let's read `multimethod/__init__.py`.

{
  "filepath": "multimethod/__init__.py"
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "import abc\nimport collections\nimport functools\nimport inspect\nimport itertools\nimport types\nimport typing\nfrom typing import Callable, Iterable, Iterator, Mapping, Union\n\n__version__ = '1.4'\n\n\ndef groupby(func: Callable, values: Iterable) -> dict:\n    \"\"\"Return mapping of key function to values.\"\"\"\n    groups = collections.defaultdict(list)  # type: dict\n    for value in values:\n        groups[func(value)].append(value)\n    return groups\n\n\ndef get_types(func: Callable) -> tuple:\n    \"\"\"Return evaluated type hints for positional required parameters in order.\"\"\"\n    if not hasattr(func, '__annotations__'):\n        return ()\n    type_hints = typing.get_type_hints(func)\n    positionals = {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}\n    annotations = [\n        type_hints.get(param.name, object)\n        for param in inspect.signature(func).parameters.values()\n        if param.default is param.empty and param.kind in positionals\n    ]  # missing annotations are padded with `object`, but trailing objects are unnecessary\n    return tuple(itertools.dropwhile(lambda cls: cls is object, reversed(annotations)))[::-1]\n\n\nclass DispatchError(TypeError):\n    pass\n\n\nclass subtype(type):\n    \"\"\"A normalized generic type which checks subscripts.\"\"\"\n\n    __origin__: type\n    __args__: tuple\n\n    def __new__(cls, tp, *args):\n        if tp is typing.Any:\n            return object\n        if isinstance(tp, typing.TypeVar):\n            if not tp.__constraints__:\n                return object\n            tp = typing.Union[tp.__constraints__]\n        origin = getattr(tp, '__extra__', getattr(tp, '__origin__', tp))\n        args = tuple(map(cls, getattr(tp, '__args__', None) or args))\n        if set(args) <= {object} and not (origin is tuple and args):\n            return origin\n        bases = (origin,) if type(origin) is type else ()\n        namespace = {'__origin__': origin, '__args__': args}\n        return type.__new__(cls, str(tp), bases, namespace)\n\n    def __init__(self, tp, *args):\n        if isinstance(self.__origin__, abc.ABCMeta):\n            self.__origin__.register(self)\n\n    def __getstate__(self) -> tuple:\n        return self.__origin__, self.__args__\n\n    def __eq__(self, other) -> bool:\n        return isinstance(other, subtype) and self.__getstate__() == other.__getstate__()\n\n    def __hash__(self) -> int:\n        return hash(self.__getstate__())\n\n    def __subclasscheck__(self, subclass: type) -> bool:\n        origin = getattr(subclass, '__extra__', getattr(subclass, '__origin__', subclass))\n        args = getattr(subclass, '__args__', ())\n        if origin is typing.Union:\n            return all(issubclass(cls, self) for cls in args)\n        if self.__origin__ is typing.Union:\n            return issubclass(subclass, self.__args__)\n        nargs = len(self.__args__)\n        if self.__origin__ is tuple and self.__args__[-1:] == (Ellipsis,):\n            nargs -= 1\n            args = args[:nargs]\n        return (  # check args first to avoid a recursion error in ABCMeta\n            len(args) == nargs\n            and issubclass(origin, self.__origin__)\n            and all(map(issubclass, args, self.__args__))\n        )\n\n    @classmethod\n    def subcheck(cls, tp: type) -> bool:\n        \"\"\"Return whether type requires checking subscripts using `get_type`.\"\"\"\n        return isinstance(tp, cls) and (\n            tp.__origin__ is not Union or any(map(cls.subcheck, tp.__args__))\n        )\n\n\ndef distance(cls, subclass: type) -> int:\n    \"\"\"Return estimated distance between classes for tie-breaking.\"\"\"\n    if getattr(cls, '__origin__', None) is typing.Union:\n        return min(distance(arg, subclass) for arg in cls.__args__)\n    mro = subclass.mro()\n    return mro.index(cls if cls in mro else object)\n\n\nclass signature(tuple):\n    \"\"\"A tuple of types that supports partial ordering.\"\"\"\n\n    parents: set\n\n    def __new__(cls, types: Iterable):\n        return tuple.__new__(cls, map(subtype, types))\n\n    def __le__(self, other) -> bool:\n        return len(self) <= len(other) and all(map(issubclass, other, self))\n\n    def __lt__(self, other) -> bool:\n        return self != other and self <= other\n\n    def __sub__(self, other) -> tuple:\n        \"\"\"Return relative distances, assuming self >= other.\"\"\"\n        return tuple(map(distance, other, self))\n\n\nclass multimethod(dict):\n    \"\"\"A callable directed acyclic graph of methods.\"\"\"\n\n    pending: set\n\n    def __new__(cls, func):\n        namespace = inspect.currentframe().f_back.f_locals\n        self = functools.update_wrapper(dict.__new__(cls), func)\n        self.pending = set()\n        self.get_type = type  # default type checker\n        homonym = namespace.get(func.__name__, self)\n        return homonym if isinstance(homonym, multimethod) else self\n\n    def __init__(self, func: Callable):\n        try:\n            self[get_types(func)] = func\n        except (NameError, AttributeError):\n            self.pending.add(func)\n\n    def register(self, *args) -> Callable:\n        \"\"\"Decorator for registering a function.\n\n        Optionally call with types to return a decorator for unannotated functions.\n        \"\"\"\n        if len(args) == 1 and hasattr(args[0], '__annotations__'):\n            return overload.register(self, *args)  # type: ignore",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 309,
  "is_truncated": true
}

I need to read more of `multimethod/__init__.py`.

{
  "filepath": "multimethod/__init__.py",
  "start_line\"": 151
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "import abc\nimport collections\nimport functools\nimport inspect\nimport itertools\nimport types\nimport typing\nfrom typing import Callable, Iterable, Iterator, Mapping, Union\n\n__version__ = '1.4'\n\n\ndef groupby(func: Callable, values: Iterable) -> dict:\n    \"\"\"Return mapping of key function to values.\"\"\"\n    groups = collections.defaultdict(list)  # type: dict\n    for value in values:\n        groups[func(value)].append(value)\n    return groups\n\n\ndef get_types(func: Callable) -> tuple:\n    \"\"\"Return evaluated type hints for positional required parameters in order.\"\"\"\n    if not hasattr(func, '__annotations__'):\n        return ()\n    type_hints = typing.get_type_hints(func)\n    positionals = {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}\n    annotations = [\n        type_hints.get(param.name, object)\n        for param in inspect.signature(func).parameters.values()\n        if param.default is param.empty and param.kind in positionals\n    ]  # missing annotations are padded with `object`, but trailing objects are unnecessary\n    return tuple(itertools.dropwhile(lambda cls: cls is object, reversed(annotations)))[::-1]\n\n\nclass DispatchError(TypeError):\n    pass\n\n\nclass subtype(type):\n    \"\"\"A normalized generic type which checks subscripts.\"\"\"\n\n    __origin__: type\n    __args__: tuple\n\n    def __new__(cls, tp, *args):\n        if tp is typing.Any:\n            return object\n        if isinstance(tp, typing.TypeVar):\n            if not tp.__constraints__:\n                return object\n            tp = typing.Union[tp.__constraints__]\n        origin = getattr(tp, '__extra__', getattr(tp, '__origin__', tp))\n        args = tuple(map(cls, getattr(tp, '__args__', None) or args))\n        if set(args) <= {object} and not (origin is tuple and args):\n            return origin\n        bases = (origin,) if type(origin) is type else ()\n        namespace = {'__origin__': origin, '__args__': args}\n        return type.__new__(cls, str(tp), bases, namespace)\n\n    def __init__(self, tp, *args):\n        if isinstance(self.__origin__, abc.ABCMeta):\n            self.__origin__.register(self)\n\n    def __getstate__(self) -> tuple:\n        return self.__origin__, self.__args__\n\n    def __eq__(self, other) -> bool:\n        return isinstance(other, subtype) and self.__getstate__() == other.__getstate__()\n\n    def __hash__(self) -> int:\n        return hash(self.__getstate__())\n\n    def __subclasscheck__(self, subclass: type) -> bool:\n        origin = getattr(subclass, '__extra__', getattr(subclass, '__origin__', subclass))\n        args = getattr(subclass, '__args__', ())\n        if origin is typing.Union:\n            return all(issubclass(cls, self) for cls in args)\n        if self.__origin__ is typing.Union:\n            return issubclass(subclass, self.__args__)\n        nargs = len(self.__args__)\n        if self.__origin__ is tuple and self.__args__[-1:] == (Ellipsis,):\n            nargs -= 1\n            args = args[:nargs]\n        return (  # check args first to avoid a recursion error in ABCMeta\n            len(args) == nargs\n            and issubclass(origin, self.__origin__)\n            and all(map(issubclass, args, self.__args__))\n        )\n\n    @classmethod\n    def subcheck(cls, tp: type) -> bool:\n        \"\"\"Return whether type requires checking subscripts using `get_type`.\"\"\"\n        return isinstance(tp, cls) and (\n            tp.__origin__ is not Union or any(map(cls.subcheck, tp.__args__))\n        )\n\n\ndef distance(cls, subclass: type) -> int:\n    \"\"\"Return estimated distance between classes for tie-breaking.\"\"\"\n    if getattr(cls, '__origin__', None) is typing.Union:\n        return min(distance(arg, subclass) for arg in cls.__args__)\n    mro = subclass.mro()\n    return mro.index(cls if cls in mro else object)\n\n\nclass signature(tuple):\n    \"\"\"A tuple of types that supports partial ordering.\"\"\"\n\n    parents: set\n\n    def __new__(cls, types: Iterable):\n        return tuple.__new__(cls, map(subtype, types))\n\n    def __le__(self, other) -> bool:\n        return len(self) <= len(other) and all(map(issubclass, other, self))\n\n    def __lt__(self, other) -> bool:\n        return self != other and self <= other\n\n    def __sub__(self, other) -> tuple:\n        \"\"\"Return relative distances, assuming self >= other.\"\"\"\n        return tuple(map(distance, other, self))\n\n\nclass multimethod(dict):\n    \"\"\"A callable directed acyclic graph of methods.\"\"\"\n\n    pending: set\n\n    def __new__(cls, func):\n        namespace = inspect.currentframe().f_back.f_locals\n        self = functools.update_wrapper(dict.__new__(cls), func)\n        self.pending = set()\n        self.get_type = type  # default type checker\n        homonym = namespace.get(func.__name__, self)\n        return homonym if isinstance(homonym, multimethod) else self\n\n    def __init__(self, func: Callable):\n        try:\n            self[get_types(func)] = func\n        except (NameError, AttributeError):\n            self.pending.add(func)\n\n    def register(self, *args) -> Callable:\n        \"\"\"Decorator for registering a function.\n\n        Optionally call with types to return a decorator for unannotated functions.\n        \"\"\"\n        if len(args) == 1 and hasattr(args[0], '__annotations__'):\n            return overload.register(self, *args)  # type: ignore",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 309,
  "is_truncated": true
}

I requested `start_line=151`, but `read_file` seems to have returned lines 1-150 again.
I'll try `read_file` again with correct parameters.

{
  "filepath": "multimethod/__init__.py",
  "start_line": 151
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "        return lambda func: self.__setitem__(args, func) or func\n\n    def __get__(self, instance, owner):\n        return self if instance is None else types.MethodType(self, instance)\n\n    def parents(self, types: tuple) -> set:\n        \"\"\"Find immediate parents of potential key.\"\"\"\n        parents = {key for key in self if isinstance(key, signature) and key < types}\n        return parents - {ancestor for parent in parents for ancestor in parent.parents}\n\n    def clean(self):\n        \"\"\"Empty the cache.\"\"\"\n        for key in list(self):\n            if not isinstance(key, signature):\n                super().__delitem__(key)\n\n    def copy(self):\n        \"\"\"Return a new multimethod with the same methods.\"\"\"\n        other = dict.__new__(type(self))\n        other.update(self)\n        return other\n\n    def __setitem__(self, types: tuple, func: Callable):\n        self.clean()\n        types = signature(types)\n        parents = types.parents = self.parents(types)\n        for key in self:\n            if types < key and (not parents or parents & key.parents):\n                key.parents -= parents\n                key.parents.add(types)\n        if any(map(subtype.subcheck, types)):\n            self.get_type = get_type  # switch to slower generic type checker\n        super().__setitem__(types, func)\n        self.__doc__ = self.docstring\n\n    def __delitem__(self, types: tuple):\n        self.clean()\n        super().__delitem__(types)\n        for key in self:\n            if types in key.parents:\n                key.parents = self.parents(key)\n        self.__doc__ = self.docstring\n\n    def __missing__(self, types: tuple) -> Callable:\n        \"\"\"Find and cache the next applicable method of given types.\"\"\"\n        self.evaluate()\n        if types in self:\n            return self[types]\n        groups = groupby(signature(types).__sub__, self.parents(types))\n        keys = groups[min(groups)] if groups else []\n        funcs = {self[key] for key in keys}\n        if len(funcs) == 1:\n            return self.setdefault(types, *funcs)\n        msg = f\"{self.__name__}: {len(keys)} methods found\"  # type: ignore\n        raise DispatchError(msg, types, keys)\n\n    def __call__(self, *args, **kwargs):\n        \"\"\"Resolve and dispatch to best method.\"\"\"\n        return self[tuple(map(self.get_type, args))](*args, **kwargs)\n\n    def evaluate(self):\n        \"\"\"Evaluate any pending forward references.\n\n        This can be called explicitly when using forward references,\n        otherwise cache misses will evaluate.\n        \"\"\"\n        while self.pending:\n            func = self.pending.pop()\n            self[get_types(func)] = func\n\n    @property\n    def docstring(self):\n        \"\"\"a descriptive docstring of all registered functions\"\"\"\n        docs = []\n        for func in set(self.values()):\n            try:\n                sig = inspect.signature(func)\n            except ValueError:\n                sig = ''\n            doc = func.__doc__ or ''\n            docs.append(f'{func.__name__}{sig}\\n    {doc}')\n        return '\\n\\n'.join(docs)\n\n\nclass multidispatch(multimethod):\n    \"\"\"Provisional wrapper for future compatibility with `functools.singledispatch`.\"\"\"\n\n\nget_type = multimethod(type)\nget_type.__doc__ = \"\"\"Return a generic `subtype` which checks subscripts.\"\"\"\nfor atomic in (Iterator, str, bytes):\n    get_type[(atomic,)] = type\n\n\n@multimethod  # type: ignore[no-redef]\ndef get_type(arg: tuple):\n    \"\"\"Return generic type checking all values.\"\"\"\n    return subtype(type(arg), *map(get_type, arg))\n\n\n@multimethod  # type: ignore[no-redef]\ndef get_type(arg: Mapping):\n    \"\"\"Return generic type checking first item.\"\"\"\n    return subtype(type(arg), *map(get_type, next(iter(arg.items()), ())))\n\n\n@multimethod  # type: ignore[no-redef]\ndef get_type(arg: Iterable):\n    \"\"\"Return generic type checking first value.\"\"\"\n    return subtype(type(arg), *map(get_type, itertools.islice(arg, 1)))\n\n\ndef isa(*types: type) -> Callable:\n    \"\"\"Partially bound `isinstance`.\"\"\"\n    return lambda arg: isinstance(arg, types)\n\n\nclass overload(collections.OrderedDict):\n    \"\"\"Ordered functions which dispatch based on their annotated predicates.\"\"\"\n\n    __get__ = multimethod.__get__\n\n    def __new__(cls, func):\n        namespace = inspect.currentframe().f_back.f_locals\n        self = functools.update_wrapper(super().__new__(cls), func)\n        return namespace.get(func.__name__, self)\n\n    def __init__(self, func: Callable):\n        self[inspect.signature(func)] = func\n\n    def __call__(self, *args, **kwargs):\n        \"\"\"Dispatch to first matching function.\"\"\"\n        for sig, func in reversed(self.items()):\n            arguments = sig.bind(*args, **kwargs).arguments\n            if all(\n                param.annotation(arguments[name])\n                for name, param in sig.parameters.items()\n                if param.annotation is not param.empty\n            ):\n                return func(*args, **kwargs)\n        raise DispatchError(\"No matching functions found\")\n\n    def register(self, func: Callable) -> Callable:\n        \"\"\"Decorator for registering a function.\"\"\"\n        self.__init__(func)  # type: ignore\n        return self if self.__name__ == func.__name__ else func  # type: ignore\n\n\nclass multimeta(type):\n    \"\"\"Convert all callables in namespace to multimethods.\"\"\"",
  "start_line": 151,
  "end_line": 300,
  "total_lines": 309,
  "is_truncated": true
}

The issue is in `distance` function (lines 96-101 in `multimethod/__init__.py`):

```python
def distance(cls, subclass: type) -> int:
    \"\"\"Return estimated distance between classes for tie-breaking.\"\"\"
    if getattr(cls, '__origin__', None) is typing.Union:
        return min(distance(arg, subclass) for arg in cls.__args__)
    mro = subclass.mro()
    return mro.index(cls if cls in mro else object)
```

The problem is `subclass.mro()`. If `subclass` is `type`, `type.mro()` is called, which throws `TypeError: unbound method type.mro() needs an argument`.

Actually, `subclass.mro()` works for any class because they inherit from `type`. But if `subclass` IS `type`, `type.mro()` is the method of the metaclass `type` itself.

Wait, I can check this in a python shell:
```python
>>> int.mro()
[<class 'int'>, <class 'object'>]
>>> type.mro()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method type.mro() needs an argument
```

So the fix is to handle the case where `subclass` is `type`.
Or more generally, use `type.mro(subclass)` instead of `subclass.mro()`.

Wait, `type.mro(subclass)` should work for any class that's an instance of `type`.

Let's check:
```python
>>> type.mro(int)
[<class 'int'>, <class 'object'>]
>>> type.mro(type)
[<class 'type'>, <class 'object'>]
```
Yes, `type.mro(subclass)` is safer.

However, some classes might not have an `mro` method (though very rare for anything that is a `type`).
But `multimethod` seems to assume `subclass` is a `type`.

Wait, let's look at `distance` call site.
It's called in `signature.__sub__`:
```python
    def __sub__(self, other) -> tuple:
        \"\"\"Return relative distances, assuming self >= other.\"\"\"
        return tuple(map(distance, other, self))
```
And `signature` is a tuple of `subtype` objects.
`subtype` objects are created from type hints.
In `signature.__new__`:
```python
    def __new__(cls, types: Iterable):
        return tuple.__new__(cls, map(subtype, types))
```
And `subtype` is a subclass of `type`.

Wait, if `subclass` is passed to `distance`, what is it?
In `__sub__(self, other)`, `other` is a `signature` (which is a tuple of `subtype`), and `self` is a `signature` (tuple of `subtype`).
`map(distance, other, self)` where `other` is `(subtype1, subtype2, ...)` and `self` is `(subtype1, subtype2, ...)`.
So `distance(cls=subtype_from_other, subclass=subtype_from_self)`.

`subtype` is a class.
If the type hint was `type`, then `subtype` will be created.
Let's see `subtype.__new__`:
```python
    def __new__(cls, tp, *args):
        if tp is typing.Any:
            return object
        if isinstance(tp, typing.TypeVar):
            # ...
        origin = getattr(tp, '__extra__', getattr(tp, '__origin__', tp))
        # ...
        bases = (origin,) if type(origin) is type else ()
        # ...
        return type.__new__(cls, str(tp), bases, namespace)
```
If `tp` is `type`, `origin` is `type`. `type(origin)` is `type`.
So `bases = (type,)`.
Then it returns `type.__new__(cls, 'type', (type,), namespace)`.
So `subtype(type)` is a class that inherits from `type`.
And since it inherits from `type`, it should have an `mro()` method.
Wait, if it inherits from `type`, it's a metaclass.
If `subclass` is a metaclass, `subclass.mro()` should still work?

Let's test:
```python
class MyMeta(type):
    pass

MyMeta.mro()
# TypeError: unbound method type.mro() needs an argument
```
Yes, because `MyMeta` is a `type` (it's a class), but its `mro` method is inherited from `type`. When called on `MyMeta` (the class), it's an unbound method of `type`.

So the fix is indeed to use `type.mro(subclass)` or handle the case where `subclass` is `type` or a metaclass.

Wait, if I use `type.mro(subclass)`, does it work for all `subtype` objects?
`subtype` is a subclass of `type`.

Let's verify the reproduction now. I need to make sure I'm actually hitting the `__missing__` path.
The provided example `f(int)` with `@multimethod def f(x: type):` should work if `multimethod` can find the match.
Wait, `f(int)`. `int` is an instance of `type`.
The signature is `(type,)`.
The `get_type(int)` returns `type` (or `subtype(type)`).
So it's an exact match.

Why did the issue report say it triggers `__missing__`?
Wait, let's read the traceback again.
```
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 174, in __missing__
    groups = groupby(signature(types).__sub__, self.parents(types))
```
Wait, there's a recursive call to `__call__`? Or maybe it's just the traceback showing the call stack.
Actually, `self[tuple(map(self.get_type, args))]` calls `__getitem__`. If it's not found, it calls `__missing__`.

In the example:
`@multimethod def f(x: type): ...`
Call `f(int)`.
`get_type(int)` is `type`.
So it looks for `(type,)` in the dict.
Wait, the key is not `(type,)` but `signature((type,))`.
Let's see `__setitem__`:
```python
    def __setitem__(self, types: tuple, func: Callable):
        self.clean()
        types = signature(types)
        # ...
        super().__setitem__(types, func)
```
So the key is a `signature` object.
When calling `f(int)`, it does `self[tuple(map(self.get_type, args))]`.
Wait, `self[...]` is `__getitem__`. `multimethod` inherits from `dict`.
`dict.__getitem__` does not call `__missing__`.
But `multimethod` is a `dict`... wait, does it override `__getitem__`?
I don't see `__getitem__` in the code I read.
Wait, `multimethod` inherits from `dict`.
But `dict` doesn't have `__missing__`. `collections.UserDict` does.
Wait, if it's a `dict` subclass, does `__getitem__` call `__missing__`?
No, only if it's a custom `__getitem__` that calls it, or if it's a class that implements `__missing__` and is used in a way that it's called.
Wait, `dict` subclasses DO NOT call `__missing__` automatically.

Wait, let me check the code again.
Ah, I see `__missing__` is defined in `multimethod`.
But `multimethod` inherits from `dict`.
In Python, `dict.__getitem__` does NOT call `__missing__`.
Only `collections.Mapping` or classes that implement their own `__getitem__` and call `__missing__`.

Wait, if `multimethod` doesn't override `__getitem__`, how can `__missing__` be called?
Let me look at the code again.
```python
class multimethod(dict):
    # ...
```
It doesn't override `__getitem__`.
Wait, maybe I missed something.
Let me read the whole file or search for `__getitem__`.

{
  "command": "grep -n \"__getitem__\" multimethod/__init__.py"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

It doesn't have `__getitem__`.
Wait, if it inherits from `dict`, and it defines `__missing__`, does it work?
Actually, `dict` in Python 3 does NOT call `__missing__`.
Wait, let me test this.
```python
class MyDict(dict):
    def __missing__(self, key):
        print(f"Missing {key}")
        return 42

d = MyDict()
print(d['a'])
```
Output:
```
Missing a
42
```
Aha! I was wrong. `dict` subclasses DO call `__missing__` if the key is not found.

Now, why was `f(int)` triggering `__missing__` in the issue, but not for me?
In the issue:
```python
@multimethod
def f(x: type):
    print("success")

f(int)
```
`get_type(int)` is `type`.
So it looks for the key `(type,)` (as a tuple) or `signature((type,))` (as a signature object)?
Wait, `__setitem__` does:
```python
    def __setitem__(self, types: tuple, func: Callable):
        self.clean()
        types = signature(types)
        # ...
        super().__setitem__(types, func)
```
So it stores the function with `signature((type,))` as the key.
In `__call__`:
```python
    def __call__(self, *args, **kwargs):
        """Resolve and dispatch to best method."""
        return self[tuple(map(self.get_type, args))](*args, **kwargs)
```
Here it calls `self[...]` with a TUPLE.
But the key in the dict is a SIGNATURE object.
A tuple is NOT equal to a `signature` object (unless `signature` is just a tuple, but it's a subclass of tuple, and it might not be the same).
Wait, `signature` inherits from `tuple`.
So `(type,) == signature((type,))`?
Yes, it should be.

Wait, let me check `signature` again.
```python
class signature(tuple):
    """A tuple of types that supports partial ordering."""
    # ...
    def __new__(cls, types: Iterable):
        return tuple.__new__(cls, map(subtype, types))
```
So `signature((type,))` is `(subtype(type),)`.
And `tuple(map(self.get_type, args))` is `(type,)` if `get_type` is `type`.
Is `(subtype(type),)` equal to `(type,)`?
No. `subtype(type)` is a different object than `type`.
Wait, let's check `subtype`:
```python
class subtype(type):
    # ...
    def __eq__(self, other) -> bool:
        return isinstance(other, subtype) and self.__getstate__() == other.__getstate__()
```
So `subtype(type) == type` is FALSE because `type` is not an instance of `subtype`.
Therefore, `(subtype(type),)` is NOT equal to `(type,)`.
So `self[...]` with a tuple will ALWAYS miss if the keys are `signature` objects.
And then `__missing__` is called.
Inside `__missing__`:
```python
    def __missing__(self, types: tuple) -> Callable:
        """Find and cache the next applicable method of given types."""
        self.evaluate()
        if types in self:
            return self[types]
        groups = groupby(signature(types).__sub__, self.parents(types))
        # ...
```
Here `types` is the tuple `(type,)`.
`signature(types)` is called, which creates `signature((type,))`, which is `(subtype(type),)`.
Then it calls `signature(types).__sub__`.
`__sub__` calls `distance`:
```python
    def __sub__(self, other) -> tuple:
        """Return relative distances, assuming self >= other."""
        return tuple(map(distance, other, self))
```
Wait, `other` is `self.parents(types)`.
`self.parents(types)` returns a set of `signature` objects.
So `map(distance, other, self)`:
`other` is a set of `signature` objects.
`self` is the `signature((type,))` object (which is a tuple of `subtype` objects).
Wait, `map` on a set and a tuple?
`other` is `self.parents(types)`.
`self` is `signature((type,))`.
`map(distance, other, self)` will iterate over `other` and `self` in parallel.
`other` contains `signature` objects. `self` is a `signature` object (which is a tuple of `subtype`).
So it's calling `distance(cls, subclass)` where `cls` is a `signature` and `subclass` is a `subtype`.
Wait, that can't be right. `distance` expects `cls` to be a type and `subclass` to be a type.
Let's re-read `distance` and `__sub__`.

```python
def distance(cls, subclass: type) -> int:
    """Return estimated distance between classes for tie-breaking."""
    if getattr(cls, '__origin__', None) is typing.Union:
        return min(distance(arg, subclass) for arg in cls.__args__)
    mro = subclass.mro()
    return mro.index(cls if cls in mro else object)

class signature(tuple):
    # ...
    def __sub__(self, other) -> tuple:
        """Return relative distances, assuming self >= other."""
        return tuple(map(distance, other, self))
```

If `self` is a `signature` (tuple of `subtype`), then `map(distance, other, self)` will pass elements of `other` and `self` to `distance`.
So `other` must also be a tuple of types (or `subtype`s).
But `self.parents(types)` returns a set of `signature` objects.
Wait:
```python
    def parents(self, types: tuple) -> set:
        """Find immediate parents of potential key."""
        parents = {key for key in self if isinstance(key, signature) and key < types}
        return parents - {ancestor for parent in parents for ancestor in parent.parents}
```
Wait, `key < types`? `key` is a `signature`, `types` is a tuple.
`signature.__lt__`:
```python
    def __lt__(self, other) -> bool:
        return self != other and self <= other

    def __le__(self, other) -> bool:
        return len(self) <= len(other) and all(map(issubclass, other, self))
```
Wait, `all(map(issubclass, other, self))`.
If `other` is a tuple and `self` is a `signature` (tuple of `subtype`).
`issubclass(type_from_other, subtype_from_self)`.
`subtype.__subclasscheck__` is implemented.
So `key < types` works.

Now back to `__missing__`:
```python
        groups = groupby(signature(types).__sub__, self.parents(types))
```
`signature(types).__sub__` is a method.
`self.parents(types)` is a set of `signature` objects.
So `CGB = groupby(func, values)`.
In `groupby(func, values)`:
```python
def groupby(func: Callable, values: Iterable) -> dict:
    """Return mapping of key function to values."""
    groups = collections.defaultdict(list)  # type: dict
    for value in values:
        groups[func(value)].append(value)
    return groups
```
`value` is a `signature` object (from `self.parents(types)`).
`func(value)` is `signature(types).__sub__(value)`.
Inside `signature.__sub__(self, other)`:
`self` is `signature(types)`. `other` is `value` (another `signature`).
`map(distance, other, self)` is called.
`other` is a `signature` (tuple of `subtype`).
`self` is a `signature` (tuple of `subtype`).
So `distance` is called with `(subtype_from_other, subtype_from_self)`.
And `subclass` is `subtype_from_self`.
`subclass.mro()` is called.
If `subtype_from_self` is `subtype(type)`, then its `mro()` fails.

Now I see!
In my reproduction, `f(int)` succeeded because... wait, why did it succeed?
Let me re-run my reproduction and check if it actually called the function or just didn't crash.
It printed "success".

Wait, if `f(int)` is called, and `self` only has one entry `signature((type,))` -> `f`.
`self[tuple(map(self.get_type, args))]` is `self[(type,)]`.
Is `(type,) == signature((type,))`?
Let's check:
```python
from multimethod import multimethod, signature, subtype
s = signature((type,))
t = (type,)
print(s == t)
```
`s` is `(subtype(type),)`. `t` is `(type,)`.
Are they equal?
Tuples are equal if their elements are equal.
Is `subtype(type) == type`?
```python
class subtype(type):
    def __init__(self, tp, *args):
        self.__origin__ = tp # simplifying
    def __getstate__(self) -> tuple:
        return self.__origin__, ()
    def __eq__(self, other) -> bool:
        return isinstance(other, subtype) and self.__getstate__() == other.__getstate__()

st = subtype(type)
print(st == type) # False, because type is not an instance of subtype
```
So `(subtype(type),) != (type,)`.
So `self[(type,)]` should miss.
And `__missing__` should be called.
And `__missing__` should fail.

Why did my reproduction succeed?
Wait, I used:
```python
@multimethod
def f(x: type):
    print("success")

f(int)
```
Maybe `get_type(int)` does NOT return `type`?
Let's check `get_type` in `multimethod/__init__.py`.

```python
get_type = multimethod(type)
get_type.__doc__ = """Return a generic `subtype` which checks subscripts."""
for atomic in (Iterator, str, bytes):
    get_type[(atomic,)] = type

@multimethod  # type: ignore[no-redef]
def get_type(arg: tuple):
    """Return generic type checking all values."""
    return subtype(type(arg), *map(get_type, arg))

@multimethod  # type: ignore[no-redef]
def get_type(arg: Mapping):
    """Return generic type checking first item."""
    return subtype(type(arg), *map(get_type, next(iter(arg.items()), ())))

@multimethod  # type: ignore[no-redef]
def get_type(arg: Iterable):
    """Return generic type checking first value."""
    return subtype(type(arg), *map(get_type, itertools.islice(arg, 1)))
```
Wait, `get_type` is itself a `multimethod`.
The first one is `get_type = multimethod(type)`. This means `get_type(x)` where `x` is any type will call `type(x)`? No, it's a bit confusing.
Wait:
```python
get_type = multimethod(type)
```
This means `get_type` is a `multimethod` wrapping the `type` function.
Wait, `type(int)` is `type`.
So `get_type(int)` calls `type(int)`, which is `type`.

So `map(self.get_type, args)` for `f(int)` will be `map(type, (int,))`, which is `(type,)`.
And we already established that `(type,) != signature((type,))`.

Wait! I just realized something.
When I ran the reproduction:
```python
from multimethod import multimethod

@multimmethod
def f(x: type):
    print("success")

f(int)
```
Actually, I wrote `from multimethod import multimethod`.
Then I used `@multimethod`.
What if `self.get_type` is not `type`?
In `multimethod.__new__`:
```python
        self.get_type = type  # default type checker
```
And in `__setitem__`:
```python
        if any(map(subtype.subcheck, types)):
            self.get_type = get_type  # switch to slower generic type checker
```
The type hint for `f` is `type`.
Is `subtype.subcheck(type)` True?
```python
    @classmethod
    def subcheck(cls, tp: type) -> bool:
        """Return whether type requires checking subscripts using `get_type`."""
        return isinstance(tp, cls) and (
            tp.__origin__ is not Union or any(map(cls.subcheck, tp.__args__))
        )
```
`tp` is `type`. `isinstance(type, subtype)` is False.
So `subtype.subcheck(type)` is False.
Thus `self.get_type` remains `type`.

So I'm still puzzled why it succeeded for me.
Let me try to run a more detailed reproduction.

{
  "command": "python3 - <<'PY'\nfrom multimethod import multimethod, signature, subtype\n\n@multimethod\ndef f(x: type):\n    print(\"success\")\n\nprint(\"--- Stage 1: calling f(int) ---\")\ntry:\n    f(int)\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\n\nprint(\"\\n--- Stage 2: Checking equality ---\")\ns = signature((type,))\nt = (type,)\nprint(f\"signature((type,)) == (type,): {s == t}\")\nprint(f\"type(s): {type(s)}, type(t): {type(t)}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "--- Stage 1: calling f(int) ---\nsuccess\n\n--- Stage 2: Checking equality ---\nsignature((type,)) == (type,): True\ntype(s): <class 'multimethod.signature'>, type(t): <class 'tuple'>\n",
  "stderr": "",
  "exit_code": 0
}