javac之Inferring Type Arguments Based on Actual Arguments

We use the following notational conventions in this section:

• Type expressions are represented using the letters A, F, U, V, and W. The letter A is only used to denote the type of an actual argument, and F is only used to denote the type of a formal parameter.

• Type parameters are represented using the letters S and T

• Arguments to parameterized types are represented using the letters X and Y.

• Generic type declarations are represented using the letters G and H.

Inference begins with a set of initial constraints of the form A << F, A = F, or A >> F, where U << V indicates that type U is convertible to type V by method invocation conversion (§5.3), and U >> V indicates that type V is convertible to type U by method invocation conversion.

These constraints are then reduced to a set of simpler constraints of the forms T :> X, T = X, or T <: X, where T is a type parameter of the method. This reduction is achieved by the procedure given below.

Given a constraint of the form A << F, A = F, or A >> F:

If F does not involve a type parameter T_j then no constraint is implied on T_j.

e.g

public <T extends InputStream> void test1(String a) { ... }

　　

Otherwise, F involves a type parameter T_j, and there are four cases to consider.

1. If A is the type of null, no constraint is implied on T_j.

2. Otherwise, if the constraint has the form A << F:

3. Otherwise, if the constraint has the form A = F:

4. Otherwise, if the constraint has the form A >> F:

1、the constraint has the form A << F

If A is a primitive type, then A is converted to a reference type U via boxing conversion and this algorithm is applied recursively to the constraint U << F.

If A is Reference type ,than:

• if F = T_j, then the constraint T_j :> A is implied.

• If F = U[], where the type U involves T_j, 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.

  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 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<..., Y_k-1, U, Y_k+1, ...>, where U is a type expression that involves T_j, then if A has a supertype of the form G<..., X_k-1, V, X_k+1, ...> where V is a type expression, this algorithm is applied recursively to the constraint V = U.

  For simplicity, assume that G takes a single type argument. If the method invocation being examined is to be applicable, it must be the case that A is a subtype of some invocation of G. Otherwise, A << F would never be true.

  In other words, A << F, where F = G<U>, implies that A << G<V> for some V. Now, since U is a type expression (and therefore[因此，所以], U is not a wildcard type argument), it must be the case that U = V, by the non-variance of ordinary parameterized type invocations.

  The formulation above merely generalizes this reasoning to generics with an arbitrary number of type arguments.

• If F has the form G<..., Y_k-1, ? extends U, Y_k+1, ...>, where U involves T_j, then if A has a supertype that is one of:

  • G<..., X_k-1, V, X_k+1, ...>, where V is a type expression. Then this algorithm is applied recursively to the constraint V << U.

    Again, let's keep things as simple as possible, and consider only the case where G has a single type argument.

    A << F in this case means A << G<? extends U>. As above, it must be the case that A is a subtype of some invocation of G. However, A may now be a subtype of either G<V>, or G<? extends V>, or G<? super V>. We examine these cases in turn. The first variation is described (generalized to multiple arguments) by the sub-bullet directly above. We therefore have A = G<V> << G<? extends U>. The rules of subtyping for wildcards imply that V << U.

  • G<..., X_k-1, ? extends V, X_k+1, ...>. Then this algorithm is applied recursively to the constraint V << U.

    Extending the analysis above, we have A = G<? extends V> << G<? extends U>. The rules of subtyping for wildcards again imply that V << U.

  • Otherwise, no constraint is implied on T_j.

    Here, we have A = G<? super V> << G<? extends U>. In general, we cannot conclude anything in this case. However, it is not necessarily an error. It may be that U will eventually be inferred to be Object, in which case the call may indeed be valid. Therefore, we simply refrain[避免，节制]  from placing any constraint on U.

• If F has the form G<..., Y_k-1, ? super U, Y_k+1, ...>, where U involves T_j, then if A has a supertype that is one of:

  • G<..., X_k-1, V, X_k+1, ...>. Then this algorithm is applied recursively to the constraint V >> U.

    As usual, we consider only the case where G has a single type argument.

    A << F in this case means A << G<? super U>. As above, it must be the case that A is a subtype of some invocation of G. A may now be a subtype of either G<V>, or G<? extendsV>, or G<? super V>. We examine these cases in turn. The first variation is described (generalized to multiple arguments) by the sub-bullet directly above. We therefore have A = G<V> << G<? super U>. The rules of subtyping for wildcards imply that V >> U.

  • G<..., X_k-1, ? super V, X_k+1, ...>. Then this algorithm is applied recursively to the constraint V >> U.

    We have A = G<? super V> << G<? super U>. The rules of subtyping for lower-bounded wildcards again imply that V >> U.

  • Otherwise, no constraint is implied on T_j.

    Here, we have A = G<? extends V> << G<? super U>. In general, we cannot conclude anything in this case. However, it is not necessarily an error. It may be that U will eventually be inferred to the null type, in which case the call may indeed be valid. Therefore, we simply refrain from placing any constraint on U.

• Otherwise, no constraint is implied on T_j.

e.g

class A<U> { }

public class Test {

	public <T extends Number> void test(
										T a,
										T[] b,
										A<T> c,
										A<? extends T> d,
										A<? super T> e) {

	}

	public void tt(){
		int a = 2;
		// int[] b = new int[]{2,4};
		Integer[] b = new Integer[]{1,2,3};
		A<Integer> c = new A<Integer>();
		A<Integer> d = new A<Integer>();
		A<Integer> e = new A<Integer>();

		test(a,b,c,d,e);
	}
}

　　

2、the constraint has the form A == F

• If F = T_j, then the constraint T_j = A is implied.

• If F = U[] where the type U involves T_j, 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.

  If the array types U[] and V[] are the same, their component types must be the same.

• If F has the form G<..., Y_k-1, U, Y_k+1, ...>, where U is type expression that involves T_j, then if A is of the form G<..., X_k-1, V, X_k+1,...> where V is a type expression, this algorithm is applied recursively to the constraint V = U.

• If F has the form G<..., Y_k-1, ? extends U, Y_k+1, ...>, where U involves T_j, then if A is one of:

  • G<..., X_k-1, ? extends V, X_k+1, ...>. Then this algorithm is applied recursively to the constraint V = U.

  • Otherwise, no constraint is implied on T_j.

• If F has the form G<..., Y_k-1, ? super U, Y_k+1 ,...>, where U involves T_j, then if A is one of:

  • G<..., X_k-1, ? super V, X_k+1, ...>. Then this algorithm is applied recursively to the constraint V = U.

  • Otherwise, no constraint is implied on T_j.

• Otherwise, no constraint is implied on T_j.

3、the constraint has the form A >> F

• If F = T_j, then the constraint T_j <: A is implied.

  We do not make use of such constraints in the main body of the inference algorithm. However, they are used in §15.12.2.8.

• If F = U[], where the type U involves T_j, 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 T_j.

  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 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<..., Y_k-1, U, Y_k+1, ...>, where U is a type expression that involves T_j, then:

  • If A is an instance of a non-generic type, then no constraint is implied on T_j.

    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 Ucan be derived from A.

  • 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 S₁, ..., S_n be the type parameters of G, and let H<U₁, ..., U_l> be the unique invocation of H that is a supertype of G<S₁, ..., S_n>, and let V = H<U₁, ..., U_l>[S_k=U]. Then, if V :> F this algorithm is applied recursively to the constraint A >> V.

      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 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 type parameter S, and there must be some (non-wildcard) invocation of H, H<U₁>, that is a supertype of G<S>. Substituting the type expression U for S will then yield a (non-wildcard) invocation of H, H<U₁>[S=U], that is a supertype of G<U>. For example, in the simplest instance, U₁might be S, in which case we have G<S> <: H<S>, and G<U> <: H<U> = H<S>[S=U] = V.

      It may be the case that H<U₁> is independent of S - that is, S does not occur in U₁ at all. However, the substitution described above is still valid - in this situation, V = H<U₁>[S=U] = H<U₁>. Furthermore, in this circumstance, G<T> <: H<U₁> for any T, and in particular G<U> <: H<U₁> = V.

      Regardless of whether U₁ depends on S, we have determined the type V, the invocation of H that is a supertype of G<U>. We can now invoke the algorithm recursively on the constraint H<X> = A >> V = H<U₁>[S=U]. We will then be able to relate the type arguments of both invocations of H and extract the relevant constraints from them.

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

      We have A = G<W> >> F = G<U> for some type expression W. Since W is a type expression (and not a wildcard type argument), it must be the case that W = U, by the invariance of parameterized types.

    • Otherwise, if A is of the form G<..., X_k-1, ? extends W, X_k+1, ...>, this algorithm is applied recursively to the constraint W >> U.

      We have A = G<? extends W> >> F = G<U> for some type expression W. It must be the case that W >> U, by the subtyping rules for wildcard types.

    • Otherwise, if A is of the form G<..., X_k-1, ? super W, X_k+1, ...>, this algorithm is applied recursively to the constraint W << U.

      We have A = G<? super W> >> F = G<U> for some type expression W. It must be the case that W << U, by the subtyping rules for wildcard types.

    • Otherwise, no constraint is implied on T_j.

• If F has the form G<..., Y_k-1, ? extends U, Y_k+1, ...>, where U is a type expression that involves T_j, then:

  • If A is an instance of a non-generic type, then no constraint is implied on T_j.

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

  • 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 S₁, ..., S_n be the type parameters of G, and let H<U₁, ..., U_l> be the unique invocation of H that is a supertype of G<S₁, ..., S_n>, and let V = H<? extends U₁, ..., ? extends U_l>[S_k=U]. Then this algorithm is applied recursively to the constraint A >> V.

      Our goal here is once more to simplify the relationship between A and F, and recursively invoke the algorithm on a simpler case, where the type argument is known to be an invocation of the same generic type as the formal.

      Assume both H and G have only a single type argument. Since we have the constraint A = H<X> >> F = G<? extends U>, where H is distinct from G, it must be the case that His some proper superclass or superinterface of G. There must be an invocation of H<Y>, such that H<X> >> H<Y>, that we can use instead of F = G<? extends U>.

      How do we compute H<Y>? As before, note that the declaration of G must introduce a type parameter S, and there must be some (non-wildcard) invocation of H, H<U₁>, that is a supertype of G<S>. However, substituting ? extends U for S is not generally valid. To see this, assume U₁ = T[].

      Instead, we produce an invocation of H, H<? extends U₁>[S=U]. In the simplest instance, U₁ might be S, in which case we have G<S> <: H<S>, and G<? extends U> <: H<?extends U> = H<? extends S>[S=U] = V.

    • Otherwise, if A is of the form G<..., X_k-1, ? extends W, X_k+1, ...>, this algorithm is applied recursively to the constraint W >> U.

      We have A = G<? extends W> >> F = G<? extends U> for some type expression W. By the subtyping rules for wildcards it must be the case that W >> U.

    • Otherwise, no constraint is implied on T_j.

• If F has the form G<..., Y_k-1, ? super U, Y_k+1, ...>, where U is a type expression that involves T_j, then A is either:

  • If A is an instance of a non-generic type, then no constraint is implied on T_j.

    Restricting the analysis to the unary case, we have the constraint A >> F = G<? super U>. A must be a supertype of the generic type G. However, since A is not a parameterized type, it cannot depend upon U in any way. It is a supertype of the type G<? super X> for every X such that ? super X is a valid type argument to G. No meaningful constraint on Ucan be derived from A.

  • 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 S₁, ..., S_n be the type parameters of G, and let H<U₁, ..., U_l> be the unique invocation of H that is a supertype of G<S₁, ..., S_n>, and let V = H<? super U₁, ..., ? super U_l>[S_k=U]. Then this algorithm is applied recursively to the constraint A >> V.

      The treatment here is analogous to the case where A = G<? extends U>. Here our example would produce an invocation H<? super U₁>[S=U].

    • Otherwise, if A is of the form G<..., X_k-1, ? super W, ..., X_k+1, ...>, this algorithm is applied recursively to the constraint W << U.

      We have A = G<? super W> >> F = G<? super U> for some type expression W. It must be the case that W << U, by the subtyping rules for wildcard types.

    • Otherwise, no constraint is implied on T_j.