Remove T.unsafe from extension method call

[sambostock]

Motivation

Sorbet doesn't know that ::FrozenRecord::Base will have ::Tapioca::Dsl::Compilers::Extensions::FrozenRecord prepended to its singleton_class. Therefore, it does not allow us to call the method provided by that module.

T.unsafe is used to allow the call, which can be improved.

Implementation

If we tell Sorbet that ConstantType will be the union of both types, it allows us to call the method.

I came up with this approach in #1046, which also makes use of an extension. I did not want to use T.usafe if possible, so I came up with this approach.

Tests

bundle exec srb tc is the test 😅

[sambostock]

Is there an alternative way to explicitly tell Sorbet that T.class_of(::FrozenRecord::Base).is_a?(Extensions::FrozenRecord)?

[vinistock]

I don't think so.

[sambostock]

My intuition was that it should also be possible to say

sig { override.returns(T::Enumerable[ConstantType]) }
def self.gather_constants
  # ...

but this doesn't seem to be the case due to the differences between type_member and type_template, which I'm not super familiar with.

Is there a good way to specify both, or is the idea here that it's not worth it since generics are erased at runtime anyway, so Module is sufficient?

[vinistock]

I don't think so.

[vinistock]

Concerning the return type of gather_constants, I think it would work to use ConstantType, but I'm not sure we'd gain a lot in terms of type checking.

[paracycle]

Is there a good way to specify both, or is the idea here that it's not worth it since generics are erased at runtime anyway, so Module is sufficient?

So a few things here:

1. We dump all of the constants returned from all the gather_constants calls into a set of Modules anyway, so having a more precise type here does not help much for that stage.
2. More importantly, this quickly gets into co/contra-variance since we would be expecting the return type of the gather_constants to be substitutable for the return type of the same method on the base class, so the type variable needs to be covariant (i.e. :out in Sorbet), but you can only declare co/contra-variant type parameters in modules and not classes, so that ends up making the whole thing more complicated to pull off. See here for reference: https://sorbet.org/docs/generics#in-out-and-variance