Calling promote_tuple_eltype() causes promote_type to change behavior

[rdeits]

Yeah, this is a weird one. Consider the following:

module X

using StaticArrays: SVector

struct Foo
    x::Int
end

struct Bar{S}
    x::Int
end

Base.convert(::Type{Foo}, b::Bar) = Foo(b.x)
Base.promote_rule(::Type{Bar{S1}}, ::Type{Bar{S2}}) where {S1, S2} = Foo

end

b1 = X.Bar{:x}(1)
b2 = X.Bar{:y}(2)

@show promote_type(typeof(b1), typeof(b2))

shows:

promote_type(typeof(b1), typeof(b2)) = X.Foo

Now try the same thing, but call the SVector constructor before looking at the result of promote_type:

module X

using StaticArrays: SVector

struct Foo
    x::Int
end

struct Bar{S}
    x::Int
end

Base.convert(::Type{Foo}, b::Bar) = Foo(b.x)
Base.promote_rule(::Type{Bar{S1}}, ::Type{Bar{S2}}) where {S1, S2} = Foo

end

b1 = X.Bar{:x}(1)
b2 = X.Bar{:y}(2)

StaticArrays.SVector(b1, b2)
@show promote_type(typeof(b1), typeof(b2))

shows:

promote_type(typeof(b1), typeof(b2)) = X.Bar

In the second example, promote_type gives the wrong result (Bar instead of Foo).

julia> versioninfo()
Julia Version 0.6.0-rc3.0
Commit ad290e93e4 (2017-06-07 11:53 UTC)
Platform Info:
  OS: macOS (x86_64-apple-darwin13.4.0)
  CPU: Intel(R) Core(TM) i7-2860QM CPU @ 2.50GHz
  WORD_SIZE: 64
  BLAS: libopenblas (USE64BITINT DYNAMIC_ARCH NO_AFFINITY Sandybridge)
  LAPACK: libopenblas64_
  LIBM: libopenlibm
  LLVM: libLLVM-3.9.1 (ORCJIT, sandybridge)

This seems like it might be a Julia bug, or it might be that StaticArrays is doing something bad with @pure. I'm using StaticArrays at 9ccda4e

[rdeits]

This does not occur with Julia 0.6-rc2, so I think it might be a Julia issue.

[rdeits]

The problem occurs because StaticArrays.promote_tuple_eltype() calls promote_type inside the @generated function's body. Here's a version that does not actually use StaticArrays but still shows the problem. Comment out the call to promote_type inside promote_tuple_eltype to see the problem go away:

module X

@generated function promote_tuple_eltype{T <: Tuple}(::Union{T,Type{T}})
    t = Union{}
    for i = 1:length(T.parameters)
        tmp = T.parameters[i]
        if tmp <: Vararg
            tmp = tmp.parameters[1]
        end
        t = promote_type(t, tmp)
    end
    return quote
        $(Expr(:meta,:pure))
        $t
    end
end

struct Foo
    x::Int
end

struct Bar{S}
    x::Int
end

Base.convert(::Type{Foo}, b::Bar) = Foo(b.x)
Base.promote_rule(::Type{Bar{S1}}, ::Type{Bar{S2}}) where {S1, S2} = Foo

end

b1 = X.Bar{:x}(1)
b2 = X.Bar{:y}(2)

X.promote_tuple_eltype((b1, b2))

# Should be Foo, but is actually Bar
@show promote_type(typeof(b1), typeof(b2))

[andyferris]

The problem occurs because StaticArrays.promote_tuple_eltype() calls promote_type inside the @generated function's body.

Oops! My bad.

(BTW the reason that promote_type has changed behavior here in v0.6-rc3 is because Jameson and I made promote_type less @pure (as it should be, since it was overridable) in JuliaLang/julia#21771. IIRC, there was another package out there where the same kind of two wrongs = right behavior thing was happening. I'll fix up promote_tuple_eltype here ASAP)

[rdeits]

No problem 😄

Is #229 the right way to fix this?

[andyferris]

I've been working on this in parallel... can you try out c089124 for me?

[andyferris]

Is #229 the right way to fix this?

Very close... I'll comment over there

[rdeits]

Yup, c089124 works for me. Thanks!