Runnable method1();

        List<Item1> method2();

        Map<Set<Item2>, String> method3();
    }

    interface GenericThing {
        Item3[] method1(String p);
        List<Item5>[] method2(String p);
    }

    interface Thing extends SuperThing, GenericThing {
        <T extends Item4> List<T> get();
    }

    interface Parent {
        Child getFirstChild();
    }

    def inspector = new TypeInspector()

    def "inspects type and caches result"() {
        expect:
        def types = inspector.getReachableTypes(Thing)
        types == [Thing, SuperThing, GenericThing, Item1, Item2, Item3, Item4, Item5, Runnable, List, Map, Set] as Set

        def types2 = inspector.getReachableTypes(Thing)
        types2.is(types)
    }

    def "inspects cyclic types"() {
        expect:

        expect:
        extract(EmptyClass).empty
    }

    static class ClassWithNonRuleMethods extends RuleSource {
        static List thing() {
            []
        }

        static <T> List<T> genericThing() {
            []
        }

        private doStuff() {}

        private <T> T selectThing(List<T> list) { null }
    }

    def "can have non-rule methods that would be invalid rules"() {