Add support for overloaded signatures and add overloaded ActiveRecordRelations sigs

[bdewater]

Motivation

Close #1789

Implementation

Based on the patch in aforementioned issue.

Tests

Updated tests.

[bdewater]

Getting an unrelated test failure on Rails 7 for Rubies 3.0-3.3, but not Ruby head for
cli check-shims it detects duplicates from Sorbet's payload

[KaanOzkan]

@bdewater it's resolved on main, you can rebase.

[bdewater]

@KaanOzkan thanks, only failing check now is for missing labels which I can't add :)

[paracycle]

@bdewater This will need to be rebased on main again, since we just merged a mandatory minimum dependency on the version of sorbet that includes support for multiple signatures in #1809.

Otherwise, we would need to do feature checking to detect if the version of Sorbet that we are operating against has support for that or not.

[bdewater]

Thanks for the feedback @paracycle! Rebased and incorporated your suggestions.

[paracycle]

Thank you!

[KaanOzkan]

This pattern doesn't seem to work

# test.rbi
class Foo
  sig { returns(T.untyped) }
  def foo; end

  sig { returns(T::Array[T.untyped]) }
  def bar; end
end

sig { params(args: T::Array[T.untyped]).returns(T::Enumerable[Foo]) }
sig { params(args: T.untyped).returns(Foo) }
def find(args); end

# test.rb
T.reveal_type(find(Foo.new.foo)) # T::Enumerable[Foo]
T.reveal_type(find(Foo.new.bar)) # T::Enumerable[Foo]

First sig always takes precedence. I'm not sure why, maybe it's a sorbet bug. We could open a ticket and revert this change until its fixed.

[bdewater]

Interesting, that does feel like a bug. T::Array[T.untyped] has to be first since T.untyped otherwise would match everything, except in this particular case when it doesn't match T.untyped 🙈

We could also generates a bit more strict sigs and flip the order so that the common case is first in case Sorbet cannot resolve the correct sig:

sig { params(args: T.any(String, Integer)).returns(Foo) }
sig { params(args: T::Array[T.any(String, Integer)]).returns(T::Enumerable[Foo]) }
def find(args); end

I think this would cover ~all cases (UUID and other string PKs, (big)int PKs)?

[KaanOzkan]

Yeah I think that's good. I assume bug doesn't happen then. I feel like String and Integer is enough but I don't have much context.

[bdewater]

T.untyped argument would be matched against the first signature since it's a subtype of everything, as Jez pointed out in the linked Sorbet issue.

Also noticed this particular issue was documented on https://sorbet.org/docs/overloads 😅

In the presence of untyped arguments, chances are high that the first overload is selected, which might not be desired.

[bdewater]

Some experimenting with the Rails console - find(nil) errors here, find({}) errors here which gives a pretty good list of types that can be passed.

[KaanOzkan]

Retried CI, strange failure.

[KaanOzkan]

CI is green but there are actually some failures. Looks like in main too. Let's hold off until we can trust CI
It's only the experimental ones so we're good.

[amomchilov]

This is missing one overload:

find can be passed a block, in which case it delegates to Enumerable#find, which returns a nilable result.

[KaanOzkan]

I think this covers it #1844

[amomchilov]

That's spot on. Thanks @KaanOzkan!