undetected method ambiguity

[SimonDanisch]

I ran into the following:

abstract FSV{N, T}
#works as expected when moved here
#Base.call{T <: FSV, X <: Array}(::Type{T}, x::X) = "excellent"
immutable Vec{N, T} <: FSV{N, T}
    x::NTuple{N, T}
end
Base.call{T <: FSV, X <: Array}(::Type{T}, x::X) = "excellent"

julia> Vec([1,2,3])
"excellent"
julia> Vec{3, Float32}([1,2,3])
ERROR: MethodError: `convert` has no method matching convert(::Type{Tuple{Float32,Float32,Float32}}, ::Array{Int64,1})

julia> versioninfo()                                                                                     
Julia Version 0.4.0-dev+6945                                                                             
Commit 90346c1 (2015-08-24 19:21 UTC)                                                                    
Platform Info:                                                                                           
  System: Windows (x86_64-w64-mingw32)                                                                   
  CPU: Intel(R) Core(TM) i3-4130 CPU @ 3.40GHz                                                           
  WORD_SIZE: 64                                                                                          
  BLAS: libopenblas (USE64BITINT DYNAMIC_ARCH NO_AFFINITY Haswell)                                       
  LAPACK: libopenblas                                                                                    
  LIBM: libopenlibm                                                                                      
  LLVM: libLLVM-3.3                                                                                                                                                                                           

@yuyichao comments: probably not #265 but similar

[vtjnash]

it's not # 265, it's an undetected method ambiguity. here's the signature of the method that matched:
call{N,T}(::Type{Test1.Vec{N,T}}, x) at none:5
vs. the one you were hoping to match:
call{T <: FSV, X <: Array}(::Type{T}, x::X)

[SimonDanisch]

This seems very similar on the newest rc2:

immutable Style{T} end

test{T <: Union{AbstractFloat, Array}}(::Array{T,3}, ::Style{:iso}) = "iso"
test{T <: Union{AbstractFloat, Array}}(::Array{T,3}, ::Style) = "default"
test(rand(Float32, 3,3,3), Style{:x}()) #both call default
test(rand(Float32, 3,3,3), Style{:iso}())

Changing declaration order also makes it work "correctly"

[JeffBezanson]

Seems to be fixed after #18457.