parameter constraints in subtype declarations can conflict with the supertype

[goretkin]

Suppose we have the following definitions

#type this into session 1
abstract Domain{T<:Number}
immutable Interval{T} <: Domain{T}
    a::T
    b::T
end

For the purposes of this issue I expect the following block of code to work exactly as the above (if you type them each into a different Julia session). Perhaps this is not a justified expectation.

#type this into session 2
immutable Interval{T<:Number} 
    a::T
    b::T
end

In both sessions, this works as expected

julia> Interval{Float64}(3,4)
Interval{Float64}(3.0,4.0)

julia> Interval("he","llo")
ERROR: type: Domain: in T, expected T<:Number, got Type{ASCIIString}

but if you go on to define in each session

Interval(a::Number,b::Number) = Interval(promote(a,b)...)

then session 1 loops on Interval(3,4.) (and any number types) but it works as I expect in session 2.
This is consistent with the following

#session 1 
julia> methods(Interval)
#2 methods for generic function "Interval":
Interval(a::Number,b::Number) at none:1
Interval{T}(a::T,b::T)

#session 2
julia> methods(Interval)
#2 methods for generic function "Interval":
Interval{T<:Number}(a::T<:Number,b::T<:Number)
Interval(a::Number,b::Number) at none:1

The solution seems to be to be redundant

#type this into session 1
abstract Domain{T<:Number}
immutable Interval{T<:Number} <: Domain{T}
    a::T
    b::T
end

Furthermore, I think this should raise some kind of red text

#a new session
abstract Domain{T<:Number}
immutable Interval{T<:String} <: Domain{T}
    a::T
    b::T
end

because it seems like that type is not able to be constructed

julia> Interval("he","llo")
ERROR: type: Domain: in T, expected T<:Number, got Type{ASCIIString}

julia> Interval(3,4)
ERROR: `Interval{T<:String}` has no method matching Interval{T<:String}(::Int64, ::Int64)

[goretkin]

I didn't look at these examples carefully, but it seems like all of the parametric abstract subtyping in Base does not rely on my expectation above

goretkin-mbp:julia goretkin$ git grep -P "abstract\s+.+{.+}\s*<:\s*.*{.+}"
base/boot.jl:#abstract DenseArray{T,N} <: AbstractArray{T,N}
base/range.jl:abstract Range{T} <: AbstractArray{T,1}
base/range.jl:abstract OrdinalRange{T,S} <: Range{T}
base/sparse/abstractsparse.jl:abstract AbstractSparseArray{Tv,Ti,N} <: AbstractArray{Tv,N}
examples/lru.jl:abstract LRU{K,V} <: Associative{K,V}
test/core.jl:abstract Qux_{T} <: Sup_{Qux_{Int},T}

[vtjnash]

probably related to #6721

also #8974

[mauro3]

#13297 has a more concise description.

[mauro3]

Another oddness caused by this:

abstract AA{T<:Number}
type A{T} <: AA{T} end
@show A<:AA  # --> false
@show subtypes(AA) #  Any[A{T<:Number}] <-- still listed as subtype


abstract BB{T<:Number}
type B{T<:Number} <: BB{T} end
@show B<:BB # --> true
@show subtypes(BB) # Any[A{T<:Number}]

[JeffBezanson]

#6383 also related