G<, Xk-1, super V, Xk+1, > Then this algorithm is applied recursively to the constraint V = U Otherwise, no constraint is implied on Tj

Such situations arise when the algorithm recurses, due to the contravariant subtyping rules associated with lower-bounded wildcards (those of the form G< super X>) It might be tempting to consider A>> F as being the same as F << A, but the problem of inference is not symmetric We need to remember which participant in the relation includes a type to be inferred

We do not make use of such constraints in the main body of the inference algorithm However, they are used in section 151228

This follows from the covariant subtype relation among array types The constraint A >> F, in this case means that A >> U[] A is therefore necessarily an array type V[], or a type variable whose upper bound is an array type V[] - otherwise the relation A >> U[] could never

If F = U[], where the type U involves Tj, then if A is an array type V[], or a type variable with an upper bound that is an array type V[], where V is a reference type, this algorithm is applied recursively to the constraint V >> U Otherwise, no constraint is implied on Tj

hold true It follows that V[] >> U[] Since array subtyping is covariant, it must be the case that V >> U

If F has the form G<, Yk-1, U, Yk+1, >, where U is a type expression that involves Tj, then:

In this case (once again restricting the analysis to the unary case), we have the constraint A >> F = G<U> A must be a supertype of the generic type G However, since A is not a parameterized type, it cannot depend upon the type argument U in any way It is a supertype of G<X> for every X that is a valid type argument to G No meaningful constraint on U can be derived from A

Our goal here is to simplify the relationship between A and F We aim to recursively invoke the algorithm on a simpler case, where the actual type argument is known to be an invocation of the same generic type declaration as the formal Let s consider the case where both H and G have only a single type argument Since we have the constraint A = H<X> >> F = G<U>, where H is distinct from G, it must be the case that H is some proper superclass or superinterface of G There must be a (non-wildcard) invocation of H that is a supertype of F = G<U> Call this invocation V If we replace F by V in the constraint, we will have accomplished the goal of relating two invocations of the same generic (as it happens, H) How do we compute V The declaration of G must introduce a formal type parameter S, and there must be some (non-wildcard) invocation of H, H<U1>, that is a supertype of

If A is an invocation of a generic type declaration H, where H is either G or superclass or superinterface of G, then: If H G , then let S1, , Sn be the formal type parameters of G, and let H<U1, , Ul> be the unique invocation of H that is a supertype of G<S1 , , Sn>, and let V = H<U1, , Ul>[Sk = U] Then, if V :> F this algorithm is applied recursively to the constraint A >> V

Otherwise, if A is of the form G<, Xk-1, W, Xk+1, >, where W is a type expression this algorithm is applied recursively to the constraint W = U