code: public static TypeVariable findIncompatibleVariable(final Type type,
                                                          final Class<?> context,
                                                          final GenericDeclarationScope contextScope,
                                                          final GenericDeclaration contextSource) {
          TypeVariable res = null;
          for (TypeVariable var : findVariables(type)) {
              final Class<?> target = getDeclarationClass(var);
              // declaration class must be context or it's outer class (even if outer = null equals will be correct)
              if (!target.equals(context) && !target.equals(TypeUtils.getOuter(context))) {
                  res = var;
                  break;
              }
              // e.g. correct class, but method generic when current context represents class
              if (!contextScope.isCompatible(GenericDeclarationScope.from(var.getGenericDeclaration()))
                      // e.g. method scope could match but actual methods differ
                      || contextSource != var.getGenericDeclaration()) {
                  res = var;
                  break;
              }
          }
          return res;
      }
docs: Generics visibility (from inside context class):
  <ul>
  <li>Generics declared on class</li>
  <li>Generics declared on outer class (if current is inner)</li>
  <li>Constructor generics (if inside constructor)</li>
  <li>Method generics (if inside method)</li>
  </ul>.
  
  @param type          type to check
  @param context       current context class
  @param contextScope  current context scope (class, method, constructor)
  @param contextSource context source object (required for method and constructor scopes)
  @return first variable, containing generic not visible from current class or null if no violations