This is a memory leak:

>>> while True:
...    def f(): pass
...    f.__doc__ = f

This also:

>>> while True:
...     f = [].append                                                                                                                                                   
...     f.__module__ = f

This is because the classes "function" and "builtin_function_or_method" do not implement tp_clear.

I'm not sure this should be backported to 3.6 and 2.7.
While this is a obvious bug, f.__module__ = f seems very unnatural.

> While this is a obvious bug, f.__module__ = f seems very unnatural.

Sure.

New changeset 3c452404ae178b742967589a0bb4a5ec768d76e0 by INADA Naoki in branch 'master':
bpo-33418: Add tp_clear for function object (GH-8058)
https://github.com/python/cpython/commit/3c452404ae178b742967589a0bb4a5ec768d76e0

This change introduced the possibility to have function objects in an inconsistent state. For example, when calling tp_clear on the function some code must be invoked that tries to ca the function but some fields are NULL causing a crash.

I think we should revert this and think better how to protect against this situation.

See also https://bugs.python.org/issue38006

I am going to re-close this until we understand exactly how this is interacting with https://bugs.python.org/issue38006 as this seems more complicated than our first hypothesis.

"f.__doc__ = f" or "f.__module__ = f" don't make any sense. It looks like a bug triggered on purpose. While it's bad, it's not a big deal.

The fix (commit 3c452404ae178b742967589a0bb4a5ec768d76e0) is causing way worse issues than the "artificial" memory leak (reference cycle). I wrote PR 15826 to revert the change in Python 3.8. bpo-38006 root issues are not well understood nor fixed yet.

I'm OK to revert it in 3.8.

But I am worrying about func.func_closure.  Can it create cyclic reference in real life applications?

New changeset ccaea525885e41c5f1e566bb68698847faaa82ca by T. Wouters (Victor Stinner) in branch '3.8':
Revert "bpo-33418: Add tp_clear for function object (GH-8058)" (GH-15826)
https://github.com/python/cpython/commit/ccaea525885e41c5f1e566bb68698847faaa82ca

> But I am worrying about func.func_closure.  Can it create cyclic reference in real life applications?

remove.__closure__ is part of a reference cycle in bpo-38006.

I like func_clear() (which is still implemented in the master branch), but we need to understand why/how it was possible *crash Python* in bpo-38006.

> It looks like a bug triggered on purpose.

Absolutely. It's one of the many small issues that I found while working on PEP 590 and related things.