import org.gradle.model.internal.type.ModelType;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

@ServiceScope(Scope.Global.class)
public class ManagedProxyFactory {
    private final ManagedProxyClassGenerator proxyClassGenerator = new ManagedProxyClassGenerator();
    private final LoadingCache<CacheKey, Class<?>> generatedImplementationTypes = CacheBuilder.newBuilder()

import org.gradle.model.internal.inspect.ModelRuleExtractor
import org.gradle.model.internal.manage.binding.StructBindingsStore
import org.gradle.model.internal.manage.instance.ManagedProxyFactory
import org.gradle.model.internal.manage.schema.ModelSchemaStore
import org.gradle.model.internal.registry.ModelRegistry
import org.gradle.test.fixtures.AbstractProjectBuilderSpec

        List<MethodModelRuleExtractor> coreExtractors = MethodModelRuleExtractors.coreExtractors(modelSchemaStore);
        return new ModelRuleExtractor(Iterables.concat(coreExtractors, extractors), managedProxyFactory, modelSchemaStore, structBindingsStore);
    }

    @Provides

                    ModelReference.of(ManagedProxyFactory.class),
                    ModelReference.of(TypeConverter.class)
                ),
                new BiAction<MutableModelNode, List<ModelView<?>>>() {
                    @Override
                    public void execute(MutableModelNode modelNode, List<ModelView<?>> modelViews) {

            });

    private final Iterable<MethodModelRuleExtractor> handlers;
    private final ManagedProxyFactory proxyFactory;
    private final ModelSchemaStore schemaStore;
    private final StructBindingsStore structBindingsStore;

    public ModelRuleExtractor(Iterable<MethodModelRuleExtractor> handlers, ManagedProxyFactory proxyFactory, ModelSchemaStore schemaStore, StructBindingsStore structBindingsStore) {

    private final StructBindings<?> bindings;
    private final ManagedProxyFactory proxyFactory;
    private final TypeConverter typeConverter;

    public ManagedModelProjection(StructSchema<M> schema,
                                  StructBindings<?> bindings,
                                  ManagedProxyFactory proxyFactory,
                                  TypeConverter typeConverter) {

    PluginManagerInternal pluginManager = Stub(PluginManagerInternal)
    PluginContainer pluginContainer = Stub(PluginContainer)
    ManagedProxyFactory managedProxyFactory = Stub(ManagedProxyFactory)
    AntLoggingAdapter antLoggingAdapter = Stub(AntLoggingAdapter)
    AttributesSchema attributesSchema = Stub(AttributesSchema)

            return serviceRegistry.get(ModelSchemaStore.class);
        }

        @Hidden
        @Model
        ManagedProxyFactory proxyFactory(ServiceRegistry serviceRegistry) {
            return serviceRegistry.get(ManagedProxyFactory.class);
        }

        @Hidden
        @Model
        StructBindingsStore structBindingsStore(ServiceRegistry serviceRegistry) {

public class ManagedProxyClassGenerator extends AbstractProxyClassGenerator {
    /*
        Note: there is deliberately no internal synchronizing or caching at this level.
        Class generation should be performed behind a ManagedProxyFactory.
     */

    private static final String STATE_FIELD_NAME = "$state";
    private static final String TYPE_CONVERTER_FIELD_NAME = "$typeConverter";

Class <org.gradle.model.internal.manage.instance.ManagedProxyFactory$1> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ManagedProxyFactory.java:0)
Class <org.gradle.model.internal.manage.instance.ManagedProxyFactory$CacheKey> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ManagedProxyFactory.java:0)