[swift-evolution] User Defined Attributes/Annotations

Akiva Leffert aleffert at gmail.com
Thu Dec 10 21:11:12 CST 2015

> On Dec 10, 2015, at 2:30 AM, Tommy van der Vorst <tommy at pixelspark.nl> wrote:
> Hi Akiva,
> You mention documentation/linting and static checks - could you elaborate a bit on what exactly the use case for user-defined annotations would be for these things? How would one define a static runtime check in your proposed syntax? 

You wouldn’t define a static runtime check directly. That's the responsibility of external tools. Swift linter tools have already started to appear, though I don’t think any of them are taking advantage of the compiler tooling yet. User defined annotations would give them a lot more options and potential power and help motivate an ecosystem. You could imagine a way to have pluggable checks be part of the core language infrastructure, but that seemed out of scope.

As an example of a check, there was a previous discussion of a scope based access control modifier. It would be relatively straightforward to define an attribute for that and linter pass for it, see if people find it has value and if so, feed it back into the core language.

Some other off the cuff examples of annotations include:
1. Key-value observable
2. Must call super
3. Animatable (as mentioned by Rudolf)
4. Should be on main thread
5. Side effect free

Some of these are just for standardizing documentation, and some could have actual checks associated with them.

I haven’t looked at this closely, but I expect it would allow several existing attributes, like IBAction and friends, to move out of the core language and into libraries.

Further, part of the point of custom annotations is to allow the community to experiment with new features without having to accept them into the core language. Having a feature like this helps prepare for whatever good ideas people have later. Some of those ideas will of course, not be good, but by allowing them to start out as user defined tags we can validate them and find the ones that have real value. You can see this sort of thing happening in the Java community around annotations like @Override and @Nonnull.

> For documentation, it would perhaps suffice if the compiler just ignored any 'unknown' annotations, but would provide them to external lint/documentation tools. Then again we already have documentation comment blocks.

I think having the compiler check that your annotations exist has value. Typos are easy to make.

> A few other use cases I can think of: serialization (annotate field name to property), concurrency (so you can implement something like @synchronized) and reflection. Not sure whether any of these are in scope for Swift 3.0 though.

Yeah, these are useful features for sure and annotations could go that way in the long term. This proposal is more of a stake in the ground to get things started and help inform the direction of those designs, while also providing enough initial value to be worthwhile on its own.

-Akiva Leffert

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20151210/660f0451/attachment.html>

More information about the swift-evolution mailing list