Since the delegation is effectively a part of a closure type, I’d expect
@DelegatesTo to have TYPE_USE target.
Of course, it’s now tailored for parameters, so it probably should be a
different annotation.
`genericTypeIndex` and `target` doesn’t make sense in TYPE_USE, so we are left
with `value`, `strategy`, and `type`.
I don’t believe it’s possible to define an owner of such closure reasonably,
because it’s kind of dangling around, and without an owner the `strategy`
doesn’t make sense. Now, `value` and `type` are essentially the same, but
`type` supports generics. I don’t have a use case for `type`, but `value` could
be covered by the following, if Groovy would support something like this:
```
@interface Requires {
Class<? extends Precondition> value()
}
abstract class Precondition {
def os = …
abstract boolean checkRequirement() // SAM target
}
@Requires({ os.windows }) // or @Requires { os.windows } could be supported
class X {}
// which should be compiled to
@Requires(X$1)
class X {
static class 1 extends Precondition {
boolean checkRequirement() {
os.windows
}
}
}
```
And with this approach there is no need for an annotation.
—
Daniil Ovchinnikov
JetBrains
> On 4 Aug 2021, at 22:00, Leonard Brünings <[email protected]> wrote:
>
> It is possible to define Closures for annotations, e.g., Spock's
> `@Requires({ os.windows })`.
> However, it is currently impossible to tell the IDE what this annotation
> will delegate to, as @DelegatesTo is only applicable for parameters.
>
> Could we either allow @DelegatesTo for TYPE_USE or mabe add a new
> dedicated annotation for that.
>
> public @interface Requires {
> Class<DelegatesTo(PreconditionContext.class) ? extends Closure> value();
> }
>
> Alternatively, we could add METHOD as target, to the annotation.
>
> public @interface Requires {
> DelegatesTo(PreconditionContext.class)
> Class<? extends Closure> value();
> }
>
> Cheers Leonard
>
