[Discussion & Vote] Implementation of hiding types and setting custom suffixes in the create dialog

[Lazy-Rabbit-2001]

As some of devs noted that an annotation would solve the problem as well, which will supersede this pr, I'm going to make a vote to hear your voice on the implementation of hiding types from the create dialog and customize suffixes in it.
👍: is the option to this pr: Adding two global settings to manage these features, i.e. users may globally manage which types should be hidden and have custom suffixes, which does not require script devs to synchronize the language features to allow the same functionalities, every time the function gets updated if possible in the far future. For addon devs, they can setup the registration and unregistration in a main script:

func _enter_tree():
    ProjectSettings.set_setting("editor/create_dialog/global_type_blocklist", [xxx, xxx, ...])
    ProjectSettings.set_setting("editor/create_dialog/global_type_suffixes", {xxx = "xxx", ...})

func _exit_tree():
    ProjectSettings.set_setting("editor/create_dialog/global_type_blocklist", [])
    ProjectSettings.set_setting("editor/create_dialog/global_type_suffixes", {})

or we can add some helper methods:

func _enter_tree():
    EditorInterface.set_types_into_create_dialog_blocklist(["xxx", ...])
    EditorInterface.set_types_custom_suffixes_in_create_dialog({ &"xxx": "yyy", ... })

func _exit_tree():
    EditorInterface.remove_types_from_create_dialog_blocklist(["xxx", ...])
    EditorInterface.remove_types_custom_suffixes_from_create_dialog({ &"xxx": "yyy", ... })

🚀 : is the option to using script features, i.e. adding a new annotation @settings (just like what I tried before) to control these features. This is script-specific and requires other languages to synchronize the same feature, even every time the feature gets updated, which is a kinda inefficient.
👀 : is the option to using metadata. Metadata is a powerful, light-weight and flexible tool that allows us to inject optional data to an object, which is the best choice among these. However, the script files cannot store the metadata, and a discussion about converting .uid into .meta was discussed and would be a breaking feature in Godot 5, so this would be hardly implemented currently.
You can share your opinions and thoughts and make discussions in this thread. The poll will be summed up and closed on Sunday.

[theraot]

Ultimately, I believe metadata will be better.

I've voted for the annotation.

Yet, I want to submit the following to your consideration:

Conceptually the annotation and the setting can co-exist. The annotation makes godot set the setting. Meanwhile the setting would be necesary for other kinds of classes, such as those created via GDExtension.

Now, how the setting is stored is another matter. I believe that writing the setting should take precedence over having the annotation. But the result I expect of having them co-exist is that everytime Godot parses the script it writes the setting. And perhaps having it be a list is not the best if we want to know how each element was set... Which is why I think ultimately metadata is better. However, this can be solved today by having a second list with the scripts that have the annotation, and have it hidden from the user (edit: I mean, the UI), plus a helper API that will check one list and fallback to the other.