[feature] inference constant propagation even for union-split methods

[rfourquet]

Consider the following example:

const PairUnion = Union{Pair{Int,Int8},Pair{Int,UInt8}}

array = PairUnion[1=>0x2]

function pair1(a)
    x, y = a[1]
    x => y
end

function pair2(a)
    xy = a[1]
    x = xy.first
    y = xy.second
    x => y
end

function pair3(a)
    xy = a[1]
    x = first(xy)
    y = last(xy)
    x => y
end

Then:

julia> @btime pair1($array)
  73.935 ns (1 allocation: 32 bytes)
1 => 0x02

julia> @btime pair2($array)
  76.299 ns (1 allocation: 32 bytes)
1 => 0x02

julia> @btime pair3($array)
  5.051 ns (0 allocations: 0 bytes)
1 => 0x02

When looking at @code_warntype, it looks like x and y are inferred to be Union{Int,Int8,UInt8} for pair1 and pair2, while in pair3 they are inferred as Int and Union{Int8,UInt8} as expected.

[KristofferC]

Seems to be something with getproperty, rewriting as

julia> function pair4(a)
           xy = a[1]
           x = getfield(xy, :first)
           y = getfield(xy, :second)
           x => y
       end
pair4 (generic function with 1 method)

julia> @code_warntype pair4(array)
Variables
  #self#::Core.Compiler.Const(pair4, false)
  a::Array{Union{Pair{Int64,Int8}, Pair{Int64,UInt8}},1}
  xy::Union{Pair{Int64,Int8}, Pair{Int64,UInt8}}
  x::Int64
  y::Union{Int8, UInt8}

Body::Union{Pair{Int64,Int8}, Pair{Int64,UInt8}}
1 ─      (xy = Base.getindex(a, 1))
│        (x = Main.getfield(xy, :first))
│        (y = Main.getfield(xy, :second))
│   %4 = (x => y)::Union{Pair{Int64,Int8}, Pair{Int64,UInt8}}
└──      return %4

makes it work well again.

[rfourquet]

Seems to be something with getproperty, rewriting as

I had suspected as well, and had tried the exact same pair4 function, but without checking the @code_warntype output, which indeed seems to solve the problem. I had only benchmarked it, which gives:

julia> @btime pair4($array)
  53.924 ns (2 allocations: 64 bytes)
1 => 0x02

So this is still not as nice as with the first/last functions. So this may not be only a problem of inference after all, but also of getfield.

[vtjnash]

It's just heuristically avoiding constant propagation when one of the arguments is union-split

[aviatesk]

Duplicate of #37610, and #39305 will fix this.