code: private boolean checkLowerBounds(final Type one, final Type two) {
          final boolean res;
          // ? super Object is impossible here due to types cleanup in tree walker
          if (notLowerBounded(one)) {
              // walker will check compatibility, and compatible type is always assignable to lower bounded wildcard
              // e.g. Number assignable to ? super Number, but Integer not assignable to ? super Number
              res = true;
          } else if (notLowerBounded(two)) {
              // lower bound could not be assigned to anything else (only opposite way is possible)
              // for example, List<? super String> is not assignable to List<String>, but
              // List<String> is assignable to List<? super String> (previous condition)
              res = false;
          } else {
              // left type's bound must be lower: not a mistake! left (super inversion)!
              res = TypeUtils.isMoreSpecific(
                      ((WildcardType) two).getLowerBounds()[0],
                      ((WildcardType) one).getLowerBounds()[0]);
          }
          return res;
      }
docs: Check lower bounded wildcard cases. Method is not called if upper bounds are not assignable.
  <p>
  When left is not lower bound - compatibility will be checked by type walker and when compatible always
  assignable. For example, String compatible (and assignable) with ? super String and Integer is not compatible
  with ? super Number (and not assignable).
  <p>
  Wen right is not lower bound, when left is then it will be never assignable. For example,
  ? super String is not assignable to String.
  <p>
  When both lower wildcards: lower bounds must be from one hierarchy and left type should be lower.
  For example,  ? super Integer and ? super BigInteger are not assignable in spite of the fact that they
  share some common types. ? super Number is more specific then ? super Integer (super inverse meaning).
  
  @param one first type
  @param two second type
  @return true when left is assignable to right, false otherwise