Method sorting bug

[timholy]

With these types:

abstract Paint{T, N}

# AbstractColor means just color, no transparency
abstract AbstractColor{T, N} <: Paint{T, N}
abstract Color{T}            <: AbstractColor{T, 3}
abstract AbstractRGB{T}      <: Color{T}
abstract AbstractGray{T}     <: AbstractColor{T, 1}

immutable RGB{T} <: AbstractRGB{T}
    r::T # Red [0,1]
    g::T # Green [0,1]
    b::T # Blue [0,1]
end

# Types with transparency
abstract Transparent{C<:AbstractColor,T,N} <: Paint{T,N}
abstract AbstractColorAlpha{C,T,N} <: Transparent{C,T,N}
immutable ColorAlpha{C<:Color,T} <: AbstractColorAlpha{C,T,4}
    c::C
    alpha::T
end

typealias RGBA{T} ColorAlpha{RGB{T},T}

and these methods:

colortype{C<:AbstractColor    }(::Type{C})                  = C
colortype{C<:AbstractColor    }(::Type{Transparent{C}})     = C
colortype{C<:AbstractColor,T  }(::Type{Transparent{C,T}})   = C
colortype{C<:AbstractColor,T,N}(::Type{Transparent{C,T,N}}) = C
colortype{P<:Transparent}(::Type{P}) = colortype(super(P))

then colortype(RGBA{Float32}) == RGB{Float32} as desired. But in this order:

colortype{C<:AbstractColor    }(::Type{C})                  = C
colortype{P<:Transparent}(::Type{P}) = colortype(super(P))
colortype{C<:AbstractColor    }(::Type{Transparent{C}})     = C
colortype{C<:AbstractColor,T  }(::Type{Transparent{C,T}})   = C
colortype{C<:AbstractColor,T,N}(::Type{Transparent{C,T,N}}) = C

it yields:

ERROR: MethodError: `colortype` has no method matching colortype(::Type{Paint{Float32,4}})
 in colortype at none:1
...

[mauro3]

Note that this is fixed with #18457.

I think this is a smaller repo (also fixed in #18457):

# doesn't work on 0.5 (but works on jb/subtypes):
abstract AbstractMyType{T}
immutable MyType{T}<:AbstractMyType{T} end
tpara{A<:AbstractMyType}(::Type{A}) = (print(1); println(" ", A, " ", supertype(A)); tpara(supertype(A)))
tpara{I}(::Type{AbstractMyType{I}}) = (println(2); I)
tpara(MyType{true})

# julia> tpara(MyType{true})
# 1 MyType{true} AbstractMyType{true}
# 1 AbstractMyType{true} Any
# ERROR: MethodError: no method matching tpara(::Type{Any})
# Closest candidates are:
#   tpara{A<:AbstractMyType{T}}(::Type{A<:AbstractMyType}) at REPL[3]:1
#   tpara{I}(::Type{AbstractMyType{I}}) at REPL[4]:1
#  in tpara(::Type{MyType{true}}) at ./REPL[3]:1

# works:
abstract AbstractMyType{T}
immutable MyType{T}<:AbstractMyType{T} end
tpara{I}(::Type{AbstractMyType{I}}) = (println(2); I) # swap method order to make it workL
tpara{A<:AbstractMyType}(::Type{A}) = (print(1); println(" ", A, " ", supertype(A)); tpara(supertype(A)))
tpara(MyType{true})

[JeffBezanson]

closed by #18457