gh-94673: Always Finalize Static Builtin Types

[ericsnowcurrently]

Static builtin types are finalized by calling _PyStaticType_Dealloc(). Currently we skip finalizing such a type if it still has subtypes (i.e. its tp_subclasses hasn't been cleared yet). The problem is that static builtin types hold several heap objects, which leak if we skip the type's finalization. This PR addresses that.

For context, there's an old comment that says the following:

// If a type still has subtypes, it cannot be deallocated.
// A subtype can inherit attributes and methods of its parent type,
// and a type must no longer be used once it's deallocated.

However, it isn't clear that is actually still true. Clearing tp_dict should mean it isn't a problem.

Furthermore, the only subtypes that might still be around come from extension modules that didn't clean them up when unloaded (i.e. extensions that do not implement multi-phase initialization, AKA PEP 489). Those objects are already leaking, so this PR doesn't change anything in that regard. Instead, this change means more objects gets cleaned up that before.

• Issue: [subinterpreters] Static types incorrectly share some objects between interpreters #94673

[ericsnowcurrently]

@vstinner, you introduced the original skipping logic that I'm basically removing. Are there any problems with the approach I'm taking?

[ericsnowcurrently]

This was split out of #94995.

[bedevere-bot]

🤖 New build scheduled with the buildbot fleet by @ericsnowcurrently for commit 74d5af3 🤖

If you want to schedule another build, you need to add the ":hammer: test-with-buildbots" label again.

[kumaraditya303]

you introduced the original skipping logic that I'm basically removing. Are there any problems with the approach I'm taking?

Hmm, this would affected extension modules which store PyTypeObject in static global if the interpreter is initialized multiple times and the extension does not initializes it's static type via PyType_Ready when it is (re)imported. Such extensions modules are already unsafe in multiple initialization scenario so there should be no impact.

[kumaraditya303]

LGTM

[vstinner]

However, it isn't clear that is actually still true. Clearing tp_dict should mean it isn't a problem.

I skipped type deallocation if they have sub-types to prevent crashes. I don't recall the details.

I got issues with subclasses: https://bugs.python.org/issue46417#msg411122 I fixed this issue with: 8ee07dd

It's a complicated issue: https://bugs.python.org/issue46417#msg411304

See also #84258

[vstinner]

Are there any problems with the approach I'm taking?

If Python is initialized multiple times (Py_Initialize + Py_Finalize called multiple times), a sub-type may try to get data from its parent static type which has been cleared. If the static type is not properly initialized, Python can crash. If the heap type is used during the finalization after the static type has been cleared, Python can crash.

Again, I don't recall the details. I don't know the crashes that I got.