code: public static GenericsInfo create(
              final GenericsContext context, final Type type, final Class<?>... ignoreClasses) {
          // root generics are required only to properly solve type
          final Map<String, Type> rootGenerics = context.visibleGenericsMap();
          // first step: solve type to replace transitive generics with direct values
          final Type actual = GenericsUtils.resolveTypeVariables(type, rootGenerics);
          final Class<?> target = context.resolveClass(actual);
  
          LinkedHashMap<String, Type> generics = GenericsResolutionUtils.resolveGenerics(actual, rootGenerics);
          generics = GenericsResolutionUtils
                  .fillOuterGenerics(actual, generics, context.getGenericsInfo().getTypesMap());
          return create(target, generics,
                  // store possible owner types from parent context
                  usePossiblyOwnerGenerics(target, context.getGenericsInfo()), ignoreClasses);
      }
docs: Type analysis in context of analyzed type. For example, resolution of field type class in context of
  analyzed class (so we can correctly resolve it's generics).In essence, the only difference with usual type
  resolution is known root generics.
  <p>
  The result is not intended to be cached as it's context-sensitive.
  
  @param context       generics context of containing class
  @param type          type to analyze (important: this must be generified type and not raw class in
  order to properly resolve generics)
  @param ignoreClasses classes to exclude from hierarchy analysis
  @return analyzed type generics info