moveToOutputDir(checkoutDir, outputDirectory, subdirectory.getOrNull())
    }

    private static File cleanTemporaryDir(FileSystemOperations fsOps, File tmpDir) {
        if (tmpDir.exists()) {
            fsOps.delete {
                it.delete(tmpDir)
            }
        }
        return tmpDir
    }

    @TypeChecked(TypeCheckingMode.SKIP)

        try {
            JarOutputStream(BufferedOutputStream(FileOutputStream(jarFile))).use { jarOutputStream ->
                if (manifestFile.exists()) {
                    jarOutputStream.addJarEntry(JarFile.MANIFEST_NAME, manifestFile)
                }
                val visited = linkedSetOf<ClassDetails>()
                for (classDetails in classGraph.entryPoints) {

                        PrecompiledPluginsBlock::class,
                        implicitImportsForPrecompiledScriptPlugins(implicitImports)
                    ),
                    classPathFiles.filter { it.exists() },
                    logger,
                ) { it } // TODO: translate paths
        }
    }

    @Suppress("DEPRECATION")
    private
    fun resolveJvmTarget(): JavaVersion =

        final Iterable<DirectoryTree> existing = Lists.newLinkedList(
            FluentIterable
                .from(fileTrees)
                .filter(new Predicate<DirectoryTree>() {
                    @Override
                    public boolean apply(DirectoryTree input) {
                        return input.getDir().exists();
                    }
                })
        );

import org.gradle.plugin.use.PluginDependenciesSpec
import org.gradle.plugin.use.PluginDependency
import org.gradle.plugin.use.PluginDependencySpec


/**
 * Receiver for the `plugins` block.
 *
 * This class exists for the sole purpose of marking the `plugins` block as a [GradleDsl] thus
 * hiding all members provided by the outer script scope.
 *
 * @see [PluginDependenciesSpec]
 */
@GradleDsl

 * exists or the container does not support creating a domain object with the specified
 * type
 */
@Suppress("extension_shadowed_by_member")
inline fun <reified U : Any> PolymorphicDomainObjectContainer<in U>.create(name: String) =
    create(name, U::class.java)


/**
 * Creates a domain object with the specified name and type if it does not exists, and adds it to the container.
 *

            parentFile.mkdirs()
            writeText(content)
        }

    fun existing(fileName: String): File =
        canonicalFile(fileName).also {
            require(it.exists()) { "$it doesn't exist" }
        }

    fun canonicalFile(fileName: String): File =
        file(fileName).canonicalFile

    fun file(fileName: String): File =
        root.resolve(fileName)

        findReport()
    }

    private TestFile findReport() {
        def reportFile = file('build/reports/profile').listFiles().find { it.name ==~ /profile-.+.html/ }
        assert reportFile && reportFile.exists()
        reportFile
    }

import org.gradle.internal.serialize.graph.Codec
import org.gradle.internal.serialize.graph.ReadContext
import org.gradle.internal.serialize.graph.WriteContext


/**
 * This class exists because PublishArtifactLocalArtifactMetadata is used as its own id, and so when serialized as an id causes
 * a lot of unnecessary and unserializable state to be dragged in.
 *

 *
 * @param T the public type of the added extension
 * @param name the name of the extension
 * @param extension the extension instance
 *
 * @throws IllegalArgumentException When an extension with the given name already exists.
 *
 * @see [ExtensionContainer.add]
 * @since 5.0
 */
@Suppress("extension_shadowed_by_member")
inline fun <reified T : Any> ExtensionContainer.add(name: String, extension: T) {
    add(typeOf<T>(), name, extension)