@Internal
    protected
    fun getContributorsInReleaseNotes(): Set<GitHubUser> {
        val (_, contributorLines, _) = parseReleaseNotes()
        return contributorLines
            .map { it.trim() }
            .filter { it.isNotEmpty() }
            .onEach { if (!contributorLineRegex.containsMatchIn(it)) throw IllegalStateException("Invalid contributor line: $it") }

                val taskPathToReports = ******@****.***ks
                    .associate { it.path to it.genericHtmlReports() + it.findTraceJson() }
                    .filter { it.value.isNotEmpty() }

                parameters.taskPathToReports = globalExtension.taskPathToReports.map { taskPathToReportsInExtension ->

        return getOnlyElement(
            getKotlinScriptClassPathProvider()
                .compilationClassPathOf(getInputClassLoaderScope())
                .getAsFiles()
                .stream()
                .filter(file -> file.getName().startsWith("gradle-kotlin-dsl-extensions"))
                .collect(toList())
        );
    }

            });
    }

    private static <T> Map<AccessorKey, T> diff(Map<AccessorKey, T> first, Map<AccessorKey, T> second) {
        return first.entrySet().stream()
            .filter(e -> !second.containsKey(e.getKey()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }

        SimpleClassMetaDataRepository<gradlebuild.docs.dsl.source.model.ClassMetaData> repository = new SimpleClassMetaDataRepository<gradlebuild.docs.dsl.source.model.ClassMetaData>()
        int counter = 0
        source.filter { File f -> f.name.endsWith(".java") || f.name.endsWith(".groovy") }.each { File f ->
            parse(f, repository)
            counter++
        }

            .entries
            .filter { "UNKNOWN" != it.key }
            .filter { model.subprojects.getSubprojectByName(it.key) != null }
            .map { SubprojectTestClassTime(model.subprojects.getSubprojectByName(it.key)!!, it.value.filter { it.testClassAndSourceSet.sourceSet != "test" }) }
            .sortedBy { -it.totalTime }
            .filter { onlyNativeSubprojectsForIntelMacs(testCoverage, it.subProject.name) }

        }

        functionalTests = topLevelFunctionalTests + functionalTestsPass
        val crossVersionTests = topLevelFunctionalTests.filter { it.testCoverage.isCrossVersionTest } + functionalTestsPass.filter { it.testCoverage.isCrossVersionTest }
        if (stage.stageName !in listOf(StageName.QUICK_FEEDBACK_LINUX_ONLY, StageName.QUICK_FEEDBACK)) {

            javaProjectBuilderFor(loader)
                .sequenceOfJavaSourcesFrom(sources)
                .flatMap { it.classes.asSequence().filter { it.isPublic } }
                .flatMap { it.methods.asSequence().filter { it.isPublic && it.parameterTypes.isNotEmpty() } }
                .map { method -> fullyQualifiedSignatureOf(method) to commaSeparatedParameterNamesOf(method) }

        extension.enabled.convention(this.name == "main")

        project.dependencies.addProvider(
            annotationProcessorConfigurationName,
            extension.enabled.filter { it }.map { "com.google.errorprone:error_prone_core:2.24.1" }
        )

        project.tasks.named<JavaCompile>(this.compileJavaTaskName) {
            options.errorprone {
                isEnabled = extension.enabled

import java.io.FilterReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * Deeply opinionated file filter that adds elements to the release notes HTML page.
 */
public class ReleaseNotesTransformer extends FilterReader {
    private File baseCss;
    private File releaseNotesCss;
    private File releaseNotesJavascript;