code: private static Type resolveWildcardTypeVariables(final WildcardType type,
                                                       final Map<String, Type> generics,
                                                       final boolean countPreservedVariables) {
          final Type res;
          if (type.getLowerBounds().length > 0) {
              // only one lower bound could be (? super A)
              final Type lowerBound = resolveTypeVariables(
                      type.getLowerBounds(), generics, countPreservedVariables)[0];
              // flatten <? super Object> to Object
              res = lowerBound == Object.class
                      ? Object.class : WildcardTypeImpl.lower(lowerBound);
          } else {
              // could be multiple upper bounds because of named generic bounds repackage (T extends A & B)
              final Type[] upperBounds = resolveTypeVariables(type.getUpperBounds(), generics, countPreservedVariables);
              // flatten <? extends Object> (<?>) to Object and <? extends Something> to Something
              res = upperBounds.length == 1 ? upperBounds[0] : WildcardTypeImpl.upper(upperBounds);
          }
          return res;
      }
docs: Some apis (like common types {@link ru.vyarus.java.generics.resolver.util.type.CommonTypeFactory}) use
  wildcards as a "composite type" (in essence, the same way as wildcards in pure variable declaration
  like {@code T extends A & B}). But it may appear, that wildcard contains only one upper bound, which
  is useless and could be unwrapped to this bound directly.
  <p>
  Note that common types resolution rely on this in order to get rid of wildcard placeholder objects.
  
  @param type                    type to repackage
  @param generics                known generics
  @param countPreservedVariables true to replace {@link ExplicitTypeVariable} too
  @return type without {@link TypeVariable}'s