fix inference of split_rest

[simeonschaub]

fixes #47326

[jakobnissen]

Just to copy a comment over from the other PR: I wonder if this aggressive constprop might be better to have directly in the lowering, if possible, such that it applies to all cases of Base.split_rest created using slurping. I don't know if it's feasible to do at the callsite though.

[aviatesk]

Good catch!

[aviatesk]

Just to copy a comment over from the other PR: I wonder if this aggressive constprop might be better to have directly in the lowering, if possible, such that it applies to all cases of Base.split_rest created using slurping. I don't know if it's feasible to do at the callsite though.

We really can't generally transform Base.split_rest into code with some fixed length, as Julia's lowering pass doesn't known type information of object being slurped.

[jakobnissen]

What I mean is - since it already lowers like below, would it be possible to somehow say "constprop the split_rest call, regardless of the type of args"? This requires no type information, I think?

julia> Meta.@lower function fun1(args...)
           head..., tail, t2 = args
           head
       end
:($(Expr(:thunk, CodeInfo(
    @ none within `top-level scope`
1 ─      $(Expr(:thunk, CodeInfo(
    @ none within `top-level scope`
1 ─     return $(Expr(:method, :fun1))
)))
│        $(Expr(:method, :fun1))
│   %3 = Core.Typeof(fun1)
│   %4 = Core.apply_type(Vararg, Core.Any)
│   %5 = Core.svec(%3, %4)
│   %6 = Core.svec()
│   %7 = Core.svec(%5, %6, $(QuoteNode(:(#= REPL[15]:1 =#))))
│        $(Expr(:method, :fun1, :(%7), CodeInfo(
    @ REPL[15]:2 within `none`
1 ─ %1 = Base.split_rest(args, 2)
│        head = Core.getfield(%1, 1)
│   %3 = Core.getfield(%1, 2)
│   %4 = Base.indexed_iterate(%3, 1)
│        tail = Core.getfield(%4, 1)
│        @_3 = Core.getfield(%4, 2)
│   %7 = Base.indexed_iterate(%3, 2, @_3)
│        t2 = Core.getfield(%7, 1)
│   @ REPL[15]:3 within `none`
└──      return head
)))
└──      return fun1
))))

[aviatesk]

would it be possible to somehow say "constprop the split_rest call, regardless of the type of args"

So you basically want to annotate @constprop :aggressive fun1 automatically since it contains slurping, or force const-prop' for Base.split_rest calls whenever they appear? The second option might be reasonable, but we will need to implement callsite @constprop annotation support first.

[jakobnissen]

I had the latter in mind, but don't know if it's technically feasible.

[simeonschaub]

I'm not sure we actually want that, since I'd expect aggressive constant prop to only really be useful in the case of statically sized iterators. Seems better to only annotate this for specific methods where we know it's profitable.

What I would've hoped though is that inference's constant prop heuristic were able to deduct profitability of constant prop here. Perhaps the issue is that tuple slicing has a bunch of hard-coded if-statements, causing the code to be considered too complicated for this?