Defining a Foo{T} constructor for Foo{T, S <: T}

[CameronBieganek]

The manual doesn't provide a definition for what it means to define a constructor for a parametric type where the number of type parameters accepted by the constructor is fewer than the number of type parameters for the type. In simple cases, it works as expected, but for more complicated cases, the lack of a formal semantics leads to mass confusion, as demonstrated by this Discourse thread.

From that thread, we came up with the following MWE.

This works:

julia> struct Bar{T, S} end

julia> Bar{T}() where {T} = T

julia> Bar{Integer}()
Integer

But this does not:

julia> struct Foo{T, S <: T} end

julia> Foo{T}() where {T} = T

julia> Foo{Integer}()
ERROR: UndefVarError: T not defined
Stacktrace:
 [1] Foo{Integer,S} where S<:Integer() at ./REPL[2]:1
 [2] top-level scope at REPL[3]:1

Without a definition of what it means to define Foo{T}() where {T} = # ... it's difficult to know if this is a bug or if this is expected behavior. And if it is the expected behavior, it would be nice to know what the semantic rule is that explains this behavior (and it would be nice to have that explanation in the manual).

[JeffBezanson]

It helps here to understand that two different processes are happening: (1) picking a method to call, and (2) once inside the method, determining the value of T (#39277 has a similar concern). (1) is based entirely on subtyping. The signature of the method is

Tuple{Type{Foo{T}}} where T

(The type the method is defined on just gets wrapped in Type{ }.)

Tuple{Type{Foo{Integer}}} is indeed a subtype, so the method matches. However determining T is a hard problem. For example currently we have

julia> intersection_env(Type{Foo{Integer}}, Type{Foo{T}} where T)
svec(Type{Foo{Integer, S} where S<:Integer}, svec(T<:(Union{Integer, S} where S<:Integer)))

so we think we don't know the value of T for sure, but we actually could. So it's basically a bug, but it's more that we need to improve the algorithm used to infer static parameter values.