Subtyping type parameters in abstract types not propagating

[mfalt]

The following seems very confusing and is possibly a bug, or could at least be handled better.
This example works as expected

abstract type Foo{S} end
struct Bar{T} <: Foo{T} end
(::Type{T})()  where T <: Foo = println(T)

Bar{Float64}() # Prints "Bar{Float64}"
Bar() # Prints "Bar"

However, if we change the first line to

abstract type Foo{S<:Number} end
struct Bar{T} <: Foo{T} end
(::Type{T})()  where T <: Foo = println(T)

Bar{Float64}() # Prints: "Bar{Float64}"
Bar() # Does not work

The following definition is now needed to catch the Bar()

(::Type{T})() where {T<:Foo{S} where S} = println(T)
Bar() # Prints "Bar"

The problem boils down to that in the second case we have
the following are equivalent and false

Bar  <: Foo # False
Bar <: Foo{S} where S<:Number # False

But that the following is true

Bar{T where T <: Number} <: Foo # True
(Bar{T} where T<:Number) <: Foo # True

So Bar means Bar{T} where T even though T has to be restricted to Number by Foo and the following is illegal: Bar{T where T}.
Shouldn't the type restrictions propagate from the supertypes, so that
Bar is equivalent to Bar{T} where T<:Number?

[JeffBezanson]

You're right; this is a long-standing issue. Duplicate of #6383

[mfalt]

Thanks! I suspected it was known, but couldn't find the issue.