fix a huge part of invalidation on defining a new Integer subtype

[nsajko]

I have no idea why this helps, it really seems like Julia should be able to infer the type of n as Int on its own. Perhaps something to do with the print-related callers of getindex taking Vararg args?

MWE:

using SnoopCompileCore
length(@snoop_invalidations begin
    struct I <: Integer end
    Csize_t
    Csize_t(::I) = Csize_t(0)
end)

It returns 5806 before this change and 46 after the change.

[KristofferC]

Seems to be a regression vs 1.11. Would be good to figure out what change caused this.

But @code_warntype shows

julia> @code_warntype ""[1:3]
...
│    %52 = n::Int64
│          (ss = Base._string_n(%52))

so it isn't an "obvious" type instability.

[nsajko]

Bisected to #49260 (30d5a34).

[JeffBezanson]

This is very strange; I'd love to know why we would infer Integer there. I would guess something to do with recursion?

[aviatesk]

I did some investigation, and this issue is quite weird. Initially, I suspected that the inference result for getindex(::String,::UnitRange{Int64}) might have been poor due to undefined globals or similar factors when it was first inferred, and that this result was being cached and reused. However, this does not seem to be the case.

➜ julia --startup-file=no --banner=no  
julia> mi = only(methods(getindex,(String,UnitRange{Int}))).specializations
MethodInstance for getindex(::String, ::UnitRange{Int64})

julia> @ccall jl_uncompress_ir(mi.def::Any, mi.cache::Any, mi.cache.inferred::Any)::Any
CodeInfo(...)

We can see the inference result cached for getindex(::String,::UnitRange{Int64}) with this code, but it appears to be inferred correctly. So I think it is likely due to subtle interactions within the logic of abstract_call_gf_by_type that the method signature _string_n(::Integer) is being used for the _string_n call. I will look into this issue further later on.

[aviatesk]

This seems to be an issue with const-prop inference. Specifically, when getindex(::String, ::UnitRange{Int}) is const-propped with PartialStruct(UnitRange{Int}, ...), the inference inside the method body doesn't work as expected, and the type of n isn't inferred. As a result, an edge inference to _string_n(n::Integer) was happening. This is a reproducer of this inference issue:

julia> descend((String,Int,)) do s, e
           s[1:e]
       end

and we can descend into %2 = < constprop > getindex(::String,::Core.PartialStruct(UnitRange{Int64}, Any[Core.Const(1), Int64]))::String (!c,!e,!n,!t,!s,!m,!u,!o,!r) and see it isn't inferred nicely. That doesn't happen for regular inference for this method, so this is an issue on the inference side.

[aviatesk]

Close this in favor of #55625.