import org.gradle.kotlin.dsl.support.serviceOf

            class DeprecationTrigger(gradle: Gradle) : ${org.gradle.kotlin.dsl.InitScriptApi::class.qualifiedName}(gradle) {
                override val fileOperations: FileOperations = gradle.serviceOf()
                override val processOperations: ProcessOperations = gradle.serviceOf()
            }

            DeprecationTrigger(gradle)
        """)

import org.gradle.internal.service.ServiceRegistry


internal
inline fun <reified T : Any> TaskInternal.serviceOf(): T =
    project.serviceOf()


inline fun <reified T : Any> Project.serviceOf(): T =
    (this as ProjectInternal).services.get()


inline fun <reified T : Any> GradleInternal.serviceOf(): T =
    services.get()


inline fun <reified T : Any> ServiceRegistry.get(): T =

        }
        if (gradle.isRootBuild) {
            gradle.serviceOf<CacheConfigurationsInternal>().setCleanupHasBeenConfigured(true)
        }
    }

    private
    suspend fun DefaultWriteContext.writeBuildOutputCleanupRegistrations(gradle: GradleInternal) {
        val buildOutputCleanupRegistry = gradle.serviceOf<BuildOutputCleanupRegistry>()
        withGradleIsolate(gradle, userTypesCodec) {

class KotlinScriptingModelBuildersRegistrationAction : ProjectConfigureAction {

    override fun execute(project: ProjectInternal) {

        val intermediateModelProvider = project.serviceOf<IntermediateToolingModelProvider>()
        val builders = project.serviceOf<ToolingModelBuilderRegistry>()

        builders.register(KotlinBuildScriptModelBuilder)
        builders.register(KotlinBuildScriptTemplateModelBuilder)

internal
fun ProjectInternal.accessorsClassPathOf(classPath: ClassPath): AccessorsClassPath {
    val stage1BlocksAccessorClassPathGenerator = serviceOf<Stage1BlocksAccessorClassPathGenerator>()
    val projectAccessorClassPathGenerator = serviceOf<ProjectAccessorsClassPathGenerator>()
    val dependenciesAccessors = serviceOf<DependenciesAccessors>()
    return (projectAccessorClassPathGenerator.projectAccessorsClassPath(this, classPath)

        beforeProject.clear()
        afterProject.clear()
    }

    private
    fun isolate(actions: IsolatedProjectActions, owner: IsolateOwner) =
        IsolatedActionSerializer(owner, owner.serviceOf(), owner.serviceOf())
            .serialize(actions)
}


private
data class IsolatedProjectActions(
    val beforeProject: IsolatedProjectActionList,
    val afterProject: IsolatedProjectActionList
)

 * limitations under the License.
 */
package org.gradle.kotlin.dsl.support

import org.gradle.api.initialization.Settings


inline fun <reified T : Any> Settings.serviceOf(): T =
    gradle.serviceOf()


internal
fun serviceRegistryOf(settings: Settings) =

        rootProject.gradleSourceRoots()
    }

    val classPathModeExceptions: List<Exception> by unsafeLazy {
        rootProject.serviceOf<ClassPathModeExceptionCollector>().exceptions
    }

    val implicitImports: List<String> by unsafeLazy {
        rootProject.serviceOf<ImplicitImports>().list
    }

    val nonProjectScriptPaths: ScriptClassPath by unsafeLazy {
        ScriptClassPath(

    }

    private
    fun withSettingsWithAssignment() {
        withSettings("""
            import org.gradle.kotlin.dsl.support.serviceOf
            data class Container(val property: Property<String>)
            fun newStringProperty(): Property<String> = gradle.serviceOf<ObjectFactory>().property(String::class.java)
            val container = Container(newStringProperty()).apply {
                property = "Hello world"

 */
package org.gradle.kotlin.dsl

import org.gradle.api.Plugin
import org.gradle.api.initialization.Settings
import org.gradle.api.plugins.PluginAware
import org.gradle.kotlin.dsl.support.serviceOf

import kotlin.reflect.KProperty


/**
 * Applies the plugin of the given type [T]. Does nothing if the plugin has already been applied.
 *