private final ModelType<T> declaringType;
    private final ModelType<R> returnType;
    private final String name;
    private final ImmutableList<ModelType<?>> paramTypes;
    private final int modifiers;

    private int cachedHashCode = -1;

    private WeaklyTypeReferencingMethod(ModelType<T> declaringType, ModelType<R> returnType, Method method) {
        if (declaringType.getRawClass() != method.getDeclaringClass()) {

        private final boolean writable;
        private final boolean declaredAsHavingUnmanagedType;
        private final ModelType<?> declaringType;

        private PropertyContext(String name, ModelType<?> type, boolean writable, boolean declaredAsHavingUnmanagedType, ModelType<?> declaringType) {
            this.name = name;
            this.type = type;
            this.writable = writable;

    }

    private WeaklyTypeReferencingMethod weakMethod(Class type, String name) {
        def declaringType = ModelType.of(type)
        def method = type.getDeclaredMethods().find { it.name == name }
        WeaklyTypeReferencingMethod.of(declaringType, ModelType.of(method.returnType), method)
    }

    def noArgs() {}

    def oneArg(String s1) {}

    }

    private ModelRuleDescriptor methodDescriptor(Class type, String methodName) {
        def declaringType = ModelType.of(type)
        def method = type.getDeclaredMethods().find { it.name == methodName }

        MethodModelRuleDescriptor.of(WeaklyTypeReferencingMethod.of(declaringType, ModelType.of(method.returnType), method))
    }

    static class ProvidesStringOne extends RuleSource {
        @Model

        for (PropertyAccessorExtractionContext accessor : accessors.values()) {
            for (Method method : accessor.getDeclaringMethods()) {
                declaredBy.add(ModelType.declaringType(method));
            }
        }
        return declaredBy.build();
    }

    @Nullable
    public PropertyAccessorExtractionContext mergeGetters() {

                        property("kind", trace.kind.name)
                        comma()
                        property("name", trace.name)
                        comma()
                        property("declaringType", firstTypeFrom(trace.trace).name)
                    }

                    PropertyKind.PropertyUsage -> {
                        property("kind", trace.kind.name)
                        comma()

        return new Simple<T>(clazz);
    }

    public static <T> ModelType<T> returnType(Method method) {
        return new Simple<T>(method.getGenericReturnType());
    }

    public static <T> ModelType<T> declaringType(Method method) {
        return new Simple<T>(method.getDeclaringClass());
    }

    @Nullable
    public static <T> ModelType<T> paramType(Method method, int i) {