}
    }

    private static void superClasses(Class<?> current, Collection<Class<?>> supers) {
        Class<?> superclass = current.getSuperclass();
        while (superclass != null) {
            supers.add(superclass);
            superclass = superclass.getSuperclass();
        }
    }

    private static void inspectClass(Class<?> type, MutableClassDetails classDetails) {

        this.returnType = returnType;
    }

    public MethodMetaData getOverriddenMethod() {
        LinkedList<ClassMetaData> queue = new LinkedList<ClassMetaData>();
        queue.add(ownerClass.getSuperClass());
        queue.addAll(ownerClass.getInterfaces());

        String overrideSignature = getOverrideSignature();

        while (!queue.isEmpty()) {
            ClassMetaData cl = queue.removeFirst();

        return superClassName;
    }

    public void setSuperClassName(String superClassName) {
        this.superClassName = superClassName;
    }

    public ClassMetaData getSuperClass() {
        return superClassName == null ? null : metaDataRepository.find(superClassName);
    }

    public List<String> getInterfaceNames() {
        return interfaceNames;
    }

            if (scopeOf(type) != null) {
                annotatedSuperTypes.add(type);
                continue;
            }

            if (type.getSuperclass() != null) {
                queue.add(type.getSuperclass());
            }
            for (Class<?> superInterface : type.getInterfaces()) {
                if (seen.add(superInterface)) {
                    queue.add(superInterface);

        if (!(lambda instanceof Serializable)) {
            return Optional.empty();
        }
        for (Class<?> lambdaClass = lambda.getClass(); lambdaClass != null; lambdaClass = lambdaClass.getSuperclass()) {
            try {
                Method replaceMethod = lambdaClass.getDeclaredMethod("writeReplace");
                replaceMethod.setAccessible(true);

        Set<Class<?>> visitedInterfaces = new HashSet<>();
        Deque<Class<?>> interfacesToCheck = new ArrayDeque<>();

        for (Class<?> type = target.getClass(); type != Object.class && type != null; type = type.getSuperclass()) {
            interfacesToCheck.addAll(Arrays.asList(type.getInterfaces()));

            allOptionElements.addAll(getMethodAnnotations(type));
            for (OptionElement element : getFieldAnnotations(type)) {

            return valueDescription;
        }
        return type + "#toString() returned null";
    }

    public static String description(ModelType<?> type) {
        if (type.getRawClass().getSuperclass() == null && type.getRawClass().getInterfaces().length == 0) {
            return type.toString();
        }
        return type + " (or assignment compatible type thereof)";
    }

    @Override

                    return;
                default:
                    throw new AssertionError("Unexpected result: " + result);
            }

            Class<? super T> superclass = type.getSuperclass();
            if (superclass != null) {
                queue.add(superclass);
            }
            for (Class<?> iface : type.getInterfaces()) {
                if (seenInterfaces.add(iface)) {

    }

    private void visitFields(Class<?> type, ValidationProblemCollector collector) {
        if (type.equals(Object.class)) {
            return;
        }
        if (type.getSuperclass() != null) {
            visitFields(type.getSuperclass(), collector);
        }

        // Disallow instance fields. This doesn't guarantee that the object is immutable, just makes it less likely

            if (containsMethod(current, method)) {
                classesContainingMethod.add(current)
            } else {
                break
            }
            current = current.getSuperclass()
        }

        for (int i = classesContainingMethod.size() - 1; i > 0; --i) {
            current = classesContainingMethod.get(i)
            if (!isInternal(current)) {