Reflect on subtypes

[HerrNiklasRaab]

Hello,

in this comment (#7 (comment)), it is mentioned that there will be a @ReflectSubtypes(reflector) annotation to mark automatically all subtypes? Is this still planned, is there a way around this at the moment? I am using a reflector from a library, so I can't just add the subtypeQuantifyCapability, mentioned here: #123 (comment)

Thanks,

Niklas

[eernstg]

The @ReflectSubtypes(reflector) design was not implemented (or even designed in detail), but the ability to cover subtypes was added in the shape of subtypeQuantifyCapability. There are no plans to introduce a new mechanism for doing this. So you'd need to use the quantifier, perhaps by creating a modified copy of the reflector that you are currently using.

If your target class set can be specified conveniently (say, they are located in a small set of libraries and/or have names that match a regexp) then you could also use @GlobalQuantifyCapability.

[HerrNiklasRaab]

Thanks @eernstg for your response!

Using a @GlobalQuantifyCapability is not possible because classes don't share any comman naming pattern.

Could you please clarify the following:

So you'd need to use the quantifier, perhaps by creating a modified copy of the reflector that you are currently using.

To get a bit more concrete. We want to set only one annotation for a base class, to enable serialization for all subtypes automatically. The reflector below is part of a library. How can we "add" the subtypeQuantifyCapability to the reflector below and still be able to use the library as intended.
Because the reflector is provided by the library, we can't modify the reflector.

/// [jsonSerializable] is used as shorthand metadata, marking classes targeted
/// for serialization / deserialization, w/o "()"
const jsonSerializable = JsonSerializable();

/// [JsonSerializable] is used as metadata, marking classes as
/// serialization / deserialization capable targets
class JsonSerializable extends Reflectable {
  const JsonSerializable()
      : super(
            instanceInvokeCapability,
            metadataCapability,
            reflectedTypeCapability,
            newInstanceCapability,
            typeRelationsCapability,
            declarationsCapability);
}

[eernstg]

I guess you're saying that this library does not only declare jsonSerializable and JsonSerializable, but it also uses jsonSerializable to perform some reflective operations, so you don't have a way to make them use a different reflector? Otherwise, if you control the code where the reflective operations are performed then you should be able to simply create your own reflector with the added subtypeQuantifyCapability, and use that.

[HerrNiklasRaab]

so you don't have a way to make them use a different reflector?

That's exactly the case. Is this a third party library limitation or should this be addressed in the reflectable library?

[eernstg]

This is about the semantics of capabilities, so it's not about a third party library, it is about reflectable.

I think you have a good case: The ability to apply an existing reflector to an entire subtype graph rather than just a single class is quite natural (and evidently useful), but isn't covered by the capabilities that we currently have.

So we could add @GlobalQuantifySubtypeCapability(C, reflector) which would associate reflector with the class C as well as all subtypes of C. That would give us the desired effect, and it seems to be the form that fits best into the current design of capabilities. However, I do not have time to work on that right now.