if (parent == null) {
            parentRegistry = rootRegistry.createChild(project.getBaseClassLoaderScope());
        } else {
            parentRegistry = parent.getMutableModel().getServices().get(PluginRegistry.class);
        }
        return parentRegistry.createChild(project.getClassLoaderScope());
    }

    @Provides

        val newScope = if (localImplementationHash != null && exportClassPath.isEmpty) {
            parent.createLockedChild(name, origin, localClassPath, localImplementationHash, null)
        } else {
            parent.createChild(name, origin).local(localClassPath).export(exportClassPath).lock()
        }

        scopes.putInstance(id, newScope)
        return newScope
    }

    private

     * The child inherits the loggers of its parent, though these can be replaced.
     *
     * @return The child
     */
    ScopedListenerManager createChild(Class<? extends Scope> scope);

    }

    public LifecycleAwareBuildCacheController createForNonRootBuild(Path identityPath, BuildCacheControllerFactory buildCacheControllerFactory, InstanceGenerator instanceGenerator) {
        return rootController.createChild(identityPath, buildCacheControllerFactory, instanceGenerator);
    }

    private static abstract class DelegatingBuildCacheController implements LifecycleAwareBuildCacheController {
        @Override

        registration.add(BuildEventConsumer.class, buildEventConsumer);
    }

    @Provides
    ScopedListenerManager createListenerManager(ScopedListenerManager parent) {
        return parent.createChild(Scope.BuildSession.class);
    }

        return fileLookup.getFileResolver(settings.getSettingsDir());
    }

    @Provides
    protected PluginRegistry createPluginRegistry(PluginRegistry parentRegistry) {
        return parentRegistry.createChild(settings.getClassLoaderScope());
    }

    @Provides
    protected PluginManagerInternal createPluginManager(
        Instantiator instantiator,
        PluginRegistry pluginRegistry,

        projectState.createMutableModel(parentProject.getClassLoaderScope().createChild("project-" + name, null), parentProject.getBaseClassLoaderScope());
        ProjectInternal project = projectState.getMutableModel();

        // Lock the project, these won't ever be released as ProjectBuilder has no lifecycle

        }

        private
        fun createSettings(): SettingsState {
            val baseClassLoaderScope = gradle.classLoaderScope
            val classLoaderScope = baseClassLoaderScope.createChild("settings", null)
            val settingsSource = TextResourceScriptSource(service<TextFileResourceLoader>().loadFile("settings file", settingsFile))
            lateinit var services: SettingsScopeServices

        return newPluginRegistryOf(instrumentedClassPath);
    }

    private PluginRegistry newPluginRegistryOf(ClassPath classPath) {
        return new DefaultPluginRegistry(pluginInspector,
            parentScope.createChild("injected-plugin", null)
                .local(classPath)
                .lock()
        );
    }

    @Override
    public void collectResolversInto(Collection<? super PluginResolver> dest) {

    }

    @Provides
    protected ScopedListenerManager createListenerManager(ScopedListenerManager parent) {
        return parent.createChild(Scope.BuildTree.class);
    }

    @Provides
    protected ExceptionAnalyser createExceptionAnalyser(LoggingConfiguration loggingConfiguration, ExceptionCollector exceptionCollector) {