Convert dispatch depends on the method order?

[maximsch2]

Using a sample code:

abstract Abs
type Foo <: Abs
end


type Bar
  val::Int64
end

type Baz
  val::Int64
end


import Base.convert


bar{T <: Abs}(x::T) = 2
bar(x) = 1

baz(x) = 1
baz{T <: Abs}(x::T) = 2


convert{T <: Abs}(::Type{Bar}, x::T) = Bar(2)
convert(::Type{Bar}, x) = Bar(1)


convert(::Type{Baz}, x) = Baz(1)
convert{T <: Abs}(::Type{Baz}, x::T) = Baz(2)


@show convert(Bar, Foo())
@show convert(Baz, Foo())

@show bar(Foo())
@show baz(Foo())

I get this on julia 0.3.11:

convert(Bar,Foo()) => Bar(2)
convert(Baz,Foo()) => Baz(2)
bar(Foo()) => 2
baz(Foo()) => 2

and this on latest 0.4:

convert(Bar,Foo()) = Bar(1)
convert(Baz,Foo()) = Baz(2)
bar(Foo()) = 2
baz(Foo()) = 2

Is this supposed to happen? Note that the only difference between Bar and Baz is in the method definition order and it only happens with convert

[vtjnash]

reduction:

julia> begin
       abstract Abs
       type Foo <: Abs; end
       type Bar; val::Int64; end
       type Baz; val::Int64; end
       fb{T}(::Type{T}, x::T) = T(3) # this definition is critical for causing 
       fb{T <: Abs}(::Type{Bar}, x::T) = Bar(2) # this method to sort incorrectly
       fb(::Type{Bar}, x) = Bar(1) # the rest don't matter for this example
       fb(::Type{Baz}, x) = Baz(1) # this method helps
       fb{T <: Abs}(::Type{Baz}, x::T) = Baz(2) # this method to end up in the place expected by the author
       end
fb (generic function with 5 methods)

julia> methods(fb)
# 5 methods for generic function "fb":
fb(::Type{Bar}, x) at none:4
fb{T<:Abs}(::Type{Baz}, x::T<:Abs) at none:8
fb(::Type{Baz}, x) at none:7
fb{T}(::Type{T}, x::T) at none:2
fb{T<:Abs}(::Type{Bar}, x::T<:Abs) at none:3

julia> fb(Baz,Foo())
Baz(2)

julia> fb(Bar,Foo())
Bar(1)

[vtjnash]

i assume this'll be fixed by #8974

[JeffBezanson]

Specificity issue, not fixed yet.

[JeffBezanson]

This is fixed now. Will add a test.