code: public static <T, S extends T> Type reify(Class<T> type, Class<S> context) {
      return reify(resolveGenericType(type, context), getTypeVariableMap(context, null));
    }
docs: Traverses a generic type and replaces all type variables and wildcard types with concrete types (if possible),
  by using the type information from given {@code context}.
  A convenience method which largely works the same as {@link #reify(Type, Class)}, but first resolves the
  generic type of {@code type}.
  
  @param type the class whose generic type to traverse
  @param context the class that serves as starting point to resolve replacements of type variables
  @return a type that is structurally the same as {@code type}, except that type variables and wildcard types
  have been replaced with concrete types
  @throws UnsupportedOperationException if {@code type} (or a type that it references) is not an instance of one of
  the following types: {@link Class}, {@link TypeVariable}, {@link WildcardType}, {@link ParameterizedType},
  {@link GenericArrayType}.
  @throws UnsupportedOperationException if {@code type} (or a type that it references) is a {@link WildcardType} that
  does not have exactly one upper bound, or does not have no lower bounds.
  @throws UnsupportedOperationException if {@code type} (or a type that it references) is a {@link GenericArrayType}
  whose generic component type cannot be reified to an instance of {@link Class}.