import javax.annotation.Nullable

class TypesTest extends Specification {
    def "base object types are not visited"() {
        when: Types.walkTypeHierarchy(Object, Mock(Types.TypeVisitor))
        then: 0 * _

        when: Types.walkTypeHierarchy(GroovyObject, [Object, GroovyObject], Mock(Types.TypeVisitor))
        then: 0 * _
    }

    class Base {
        @Incubating
        Object doSomething() { null }

     *
     * @param clazz the type of whose type hierarchy to visit.
     * @param visitor the visitor to call for each type in the hierarchy.
     */
    public static <T> void walkTypeHierarchy(Class<T> clazz, TypeVisitor<? extends T> visitor) {
        walkTypeHierarchy(clazz, OBJECT_TYPE, visitor);
    }

    /**
     * Visits all types in a type hierarchy in breadth-first order, super-classes first and then implemented interfaces.
     *

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import static org.gradle.internal.reflect.Methods.SIGNATURE_EQUIVALENCE;
import static org.gradle.internal.reflect.Types.walkTypeHierarchy;

public class ModelSchemaUtils {
    public static final List<Class<?>> IGNORED_OBJECT_TYPES = ImmutableList.of(Object.class, GroovyObject.class);

    /**

import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static org.gradle.internal.reflect.Types.walkTypeHierarchy;

public class BaseInstanceFactory<PUBLIC> implements InstanceFactory<PUBLIC> {
    private final ModelType<PUBLIC> baseInterface;

import static org.gradle.internal.reflect.PropertyAccessorType.hasVoidReturnType;
import static org.gradle.internal.reflect.PropertyAccessorType.takesSingleParameter;
import static org.gradle.internal.reflect.Types.walkTypeHierarchy;

public class DefaultStructBindingsStore implements StructBindingsStore {
    private final LoadingCache<CacheKey, StructBindings<?>> bindings = CacheBuilder.newBuilder()
        .weakValues()

        AtomicReference<Type> foundType = new AtomicReference<>();
        Map<Type, Type> collectedTypes = new HashMap<>();
        Types.walkTypeHierarchy(implementationType, type -> {
            for (Type genericInterface : type.getGenericInterfaces()) {
                if (collectTypeParameters(genericInterface, foundType, collectedTypes, typeArgumentIndex)) {

import static org.gradle.internal.reflect.PropertyAccessorType.IS_GETTER;
import static org.gradle.internal.reflect.PropertyAccessorType.SETTER;
import static org.gradle.internal.reflect.Types.walkTypeHierarchy;
import static org.gradle.model.internal.manage.schema.extract.ModelSchemaUtils.IGNORED_OBJECT_TYPES;
import static org.objectweb.asm.Opcodes.ACC_FINAL;
import static org.objectweb.asm.Opcodes.ACC_PRIVATE;