a.attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType.class, "gradle-source-folders"));
        });
        sourcesPath.setCanBeConsumed(false);
        sourcesPath.setCanBeResolved(true);
        sourcesPath.setVisible(false);
        sourcesPath.extendsFrom(runtimeClasspath);

        extension.getClasspath().from(runtimeClasspath);

        throw new UnsupportedOperationException(String.format("Cannot convert path %s to a relative path.", path));
    }

    @Override
    public boolean canResolveRelativePath() {
        return false;
    }

    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        ParameterMetaData that = (ParameterMetaData) o;
        return Objects.equals(name, that.name) &&
            Objects.equals(type, that.type);
    }

    @Override
    public int hashCode() {

 * Team City.
 */

val testFilesCleanup = extensions.create<TestFileCleanUpExtension>("testFilesCleanup").apply {
    reportOnly.convention(false)
}

if ("CI" in System.getenv() && project.name != "gradle-kotlin-dsl-accessors") {
    rootProject.plugins.apply(TestFilesCleanupRootPlugin::class.java)

    protected abstract Violation checkSuperClassChanges(JApiClass apiClass, CtClass oldClass, CtClass newClass)

    protected boolean isInternal(CtClass c) {
        if (c.name.startsWith("java.")) {
            return false
        } else if (c.name.contains('.internal.')) {
            return true
        } else {
            return !publicApiPatterns.any { it.matcher(c.name).find() }
        }
    }

            attributes.attribute(Attributes.artifactType, INSTRUMENTATION_METADATA)
            isCanBeResolved = true
            isCanBeConsumed = false
            extendsFrom(other)
        }
        return runtimeInstrumentationMetadata.toProjectsOnlyView()
    }

    fun Configuration.toInstrumentationMetadataView(): FileCollection {

 */

package org.gradle.kotlin.dsl.internal.sharedruntime.codegen


val fileHeader: String
    get() = fileHeaderFor(kotlinDslPackageName)


fun fileHeaderFor(packageName: String, isIncubating: Boolean = false) =
    """$licenseHeader

@file:Suppress(
    "unused",
    "nothing_to_inline",
    "useless_cast",
    "unchecked_cast",
    "extension_shadowed_by_member",
    "redundant_projection",

sealed class IsolateOwners : IsolateOwner {

    class OwnerTask(
        override val delegate: Task,
        // TODO:configuration-cache - consider immutability
        var allowTaskReferences: Boolean = false
    ) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = (delegate.project as ProjectInternal).services.get(type)
    }

    class OwnerGradle(override val delegate: Gradle) : IsolateOwners() {

    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj == null || obj.getClass() != getClass()) {
            return false;
        }
        ImmutableManagedValueSnapshot other = (ImmutableManagedValueSnapshot) obj;
        return other.className.equals(className) && Objects.equals(other.value, value);
    }

    @Override

                systemProperty(JAVA_INSTALLATIONS_PATHS_PROPERTY, this)
            }

            outputs.cacheIf { false }
            outputs.file(outputJson)

            develocity.predictiveTestSelection.enabled = false
        }

    private
    fun Project.createPerformanceTestReportTask(name: String, reportGeneratorClass: String): TaskProvider<PerformanceTestReport> {