Declaration registration

[dabrahams]

There's a pattern that comes up, e.g. in test and serialization frameworks, that I don't think we currently have a good answer for. Basically, it generalizes to this: declaring certain kinds of things causes those things to be "registered" somehow into a dynamically traversable data structure. One example from Swift is XCTestCase. In languages with mutable globals this might translate into simply ensuring that certain code isn't dead-stripped, but we'd need to build these data structures at module load time or something.

There's no hurry to come up with this feature, but I wanted to create a marker for it.

[DmT021]

Would be pretty useful to have an ability to add arbitrary associated tags to declarations. Go calls them "struct tags". Java - annotations. C# - attributes. Swift doesn't have them, but to some extent they could be mimicked by property wrappers and macros.
They all are limited, so I'd like to highlight some of their limitations, to not repeat them:

1. In Go they are untyped. It's basically string-string dictionaries. A good solution would allow any type that can be built in compile time from any supported literal.
2. In Go, Java and C# they are only accessible via reflection. A good solution would be to incorporate them in the type system, and allow them to be accessed statically.
3. In Swift property wrappers are wrappers around values, not the declaration of the property itself, so they are only accessible on instances, not types.
4. In Swift macros are transformed at compile time, so they aren't really "attached" to declarations. A programmer is required to invent their own way to build a relation between the declaration and the metadata the macro generated. Usually via keypaths or reflection.
5. None of these languages provide a way to impose a requirement for a declaration to actually have specific attached metadata. I.e. there's no way to enforce all implementations of an interface/protocol to have a certain tag. And there's no way to express a requirement that all declarations within all implementations of an interface/protocol to have a certain tag.
6. In Swift there's no way to easily combine several property wrappers on the same property to be used independently - they all nested into each other. In Java, C# - they lays flat, like an array. There's no advanced rules to managed combinations. Sometimes it's ok to have two attributes of the same type on a property, but sometimes it's not. A good solution should have well defined rules for composability (I think for real world problems concept "at most one attribute of each type per declaration" is fine, but I'm not sure).
7. In all these languages there's no concept of self referencing from an entity to its meta. I.e. from a function there's no way to read its attribute(s) without explicit naming.