A TypeEnvironment that approximates the unresolved components of a generic simple type or collection to their nearest upper binding. The returned type is always fully resolved.

The concept of "type approximation" is not really sound in general. This class just does what we need within the Hibernate Annotations environment. It's more or less a hack. The idea is that certain types can provide useful information even if they're not fully resolved in the environment. This class tries to turn those types into the nearest fully resolved type that still carries that information.

For example:
T becomes Object.
T extends Foo becomes Foo.
List<T> becomes List<Object>.
List<T extends Foo> becomes List<Foo>.
An array of T extends Foo becomes an array of Foo.

If a type variable has multiple upper bounds, it will be approximated to Object. Lower bounds are ignored.

Wildcards are generally not approximated. Class<?> stays Class<?>. A wildcard within a generic collection is approximated to its upper binding. List<?> becomes List<Object>

Note that Class<T> is not approximated Class<Object>. That would be wrong in any situation. All parametric types that are not type variables, collections or arrays are coarsely approximated to Object.class.