def _rename_parameter(since, old, new, func=None):
    """
    Decorator indicating that a function parameter is being renamed.

    The actual implementation of *func* should use *new*, not *old*.

    Examples
    --------

    ::
        @_rename_parameter("3.1", "bad_name", "good_name")
        def func(good_name): ...
    """

    if func is None:
        return functools.partial(_rename_parameter, since, old, new)

    new_sig = inspect.signature(func)
    old_sig = new_sig.replace(parameters=[
        param.replace(name=old) if param.name == new else param
        for param in new_sig.parameters.values()])

    def _bind_or_none(signature, *args, **kwargs):
        try:
            return signature.bind(*args, **kwargs)
        except TypeError:
            return None

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except TypeError:
            new_ba = _bind_or_none(new_sig, *args, **kwargs)
            if new_ba is not None:
                # Args match the new signature, so the TypeError was not raised
                # during argument binding; reraise it.
                raise
            old_ba = _bind_or_none(old_sig, *args, **kwargs)
            if old_ba is None:
                # Args match neither the old nor the new signature; reraise the
                # argument binding failure.
                raise
        # Move out of the except: block to avoid exception chaining.  The
        # function was called with the old signature.  Emit a deprecation
        # warning and call with the new signature.
        warn_deprecated(
            since, message=f"The {old!r} argument of "
            f"{func.__name__}() has been renamed {new!r} since "
            f"{since}; support for the old name will be dropped "
            f"%(removal)s.")
        return func(*old_ba.args,
                    **{key if key is not old else new: value
                       for key, value in old_ba.kwargs.items()})

    return wrapper