Function method

python/tvm_ffi/dataclasses/py_class.py:240–292

Mark a ``@py_class`` method for FFI TypeMethod registration. Decorate any staticmethod or plain instance method on a ``@py_class`` body to have it land in the C-level ``TVMFFITypeInfo.methods[]`` table. Once registered, the method is resolvable by name from any FFI consumer — Python

(fn: Any)

def method(fn: Any) -> Any:
    """Mark a ``@py_class`` method for FFI TypeMethod registration.

    Decorate any staticmethod or plain instance method on a ``@py_class``
    body to have it land in the C-level ``TVMFFITypeInfo.methods[]``
    table. Once registered, the method is resolvable by name from any
    FFI consumer — Python-side reflection via ``TypeInfo.methods``,
    C++, Rust — through the same path already used by C++-defined
    methods declared via ``refl::ObjectDef<T>().def(...)``.

    Example::

        from tvm_ffi import Object, method
        from tvm_ffi.dataclasses import py_class


        @py_class("example.Node")
        class Node(Object):
            x: int

            @method
            def label(self) -> str:
                return f"N({self.x})"


        # The method is now in ``TypeInfo.methods`` and FFI-callable:
        info = Node.__tvm_ffi_type_info__
        fn = next(m.func for m in info.methods if m.name == "label")
        fn(Node(x=7))  # -> "N(7)"

    ``staticmethod`` is supported: the marker is written onto the
    underlying function and unwrapped at registration time. Plain
    functions are also accepted — the marker lives on the function
    object directly. ``classmethod`` is rejected at decoration time
    because its ``cls``-first dispatch does not match the
    packed-call convention.
    """
    if isinstance(fn, staticmethod):
        fn.__func__.__ffi_method__ = True
        return fn
    if isinstance(fn, classmethod):
        raise TypeError(
            "@tvm_ffi.method: @classmethod is not supported for FFI "
            "TypeMethod registration — the classmethod's ``cls`` first "
            "arg does not match the packed-call convention. Use "
            "@staticmethod or a plain instance method instead.",
        )
    if not callable(fn):
        raise TypeError(
            f"@tvm_ffi.method: expected a callable, got {type(fn).__name__}.",
        )
    fn.__ffi_method__ = True
    return fn


def _is_method_marked(value: Any) -> bool: