code: private boolean compareLowerBounds(final Type one, final Type two) {
          final boolean res;
          // ? super Object is impossible here due to types cleanup in tree walker
          if (notLowerBounded(two)) {
              // ignore possible left lower bound when simple type on the right (not Object - root condition above)
              res = true;
          } else if (notLowerBounded(one)) {
              // special case: left is Object and right is lower bounded wildcard
              // e.g Object and ? super String (last is more specific, while it's upper bound is Object too)
              // otherwise, any non Object is more specific
              res = one != Object.class;
          } 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 equal.
  <p>
  If right is not lower wildcard - no matter what left is - it's always more specific.
  <p>
  If right is lower wildcard and left is simple class then right could be more specific only when left is Object.
  Note that in this case left could be not Object as any type is more specific then Object (lower wildcard upper
  bound).
  <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 more specific, false otherwise