better upper bounds in apply_type_tfunc for NamedTuple

[quinnj]

Here's an example where the resulting NamedTuple{names, _A) where _A type is not ideal since it completely discards valid information up to that point.

8 ── %21 = Base.getfield(%14, :id)::Array{Int64,1}
│    %22 = Base.arrayref(true, %21, %15)::Int64
│    %23 = Base.getfield(%16, :salary)::Array{Union{Missing, Float64},1}
│    %24 = Base.arrayref(true, %23, %17)::Union{Missing, Float64}
│    %25 = (isa)(%24, Missing)::Bool
└───       goto #10 if not %25
9 ──       goto #13
10 ─ %28 = (isa)(%24, Float64)::Bool
└───       goto #12 if not %28
11 ─ %30 = π (%24, Float64)
│    %31 = Base.sitofp(Float64, 2)::Float64
│    %32 = Base.mul_float(%30, %31)::Float64
└───       goto #13
12 ─       Core.throw(ErrorException("fatal error in type inference (type bound)"))::Union{}
└───       $(Expr(:unreachable))::Union{}
13 ┄ %36 = φ (#9 => $(QuoteNode(missing)), #11 => %32)::Union{Missing, Float64}
│    %37 = Core.tuple(%22, %36)::Tuple{Int64,Union{Missing, Float64}}
│    %38 = (NamedTuple{(:id, :y),T} where T<:Tuple)(%37)::NamedTuple{(:id, :y),_A} where _A

@JeffBezanson thought it should be valid/fine to include an upper bound here, so that we end up with NamedTuple{(:id, :y), _A} where _A <: Tuple{Int64, Union{Missing, Float64}

[bramtayl]

How can I help here? I know basically no C++ or Scheme but willing to learn. I'd really like to be able to use vanilla NamedTuples in LightQuery

[quinnj]

Note that @JeffBezanson and I had a quick chat about this offline and #33326 currently takes priority to improve compiler times before we add a bit more work for it.

[bramtayl]

@JeffBezanson sorry to bother you but looking for an update here. I was considering moving LightQuery over to using Base NamedTuples in hopes that some day performance issues will be resolved. Is that likely to happen at some point?

[bramtayl]

Yay!!! I've been playing around with this and it's working great. I'm running into problems with pairs, though? Which is inconvenient because keyword arguments get passed through pairs?

function test()
    pairs((a = if rand(Bool)
        1
    else
        "1"
    end,))
end
@code_warntype(test())
# Body::Base.Iterators.Pairs{Symbol,_A,Tuple{Symbol},_B} where _B where _A

[bramtayl]

Nope, nevermind I don't think pairs the problem I hit. Instead, I'm having trouble merging in new (unstable) fields based on old (unstable) fields.

function test()
    data = (a = if rand(Bool)
        1
    else
        "1"
    end,)
    merge(data, (b = data.a,))
end
@code_warntype test() # NamedTuple{(:a, :b),_A} where _A<:Tuple

[bramtayl]

And also, that propertynames for NamedTuples isn't pure. Given that they are encoded in the type for named tuples and part of the public interface, it seems like it might be a reasonable thing to do.

[bramtayl]

Well anyways, the master version of LightQuery uses Base named tuples. It is a lot more convenient to use for sure. But benchmarking seems to show that performance goes out the window once you add a column with an unstable eltype.

[bramtayl]

Should I open an issue for the merge problem?