}

    protected fun collectElementsToResolve(
        carets: List<CaretMarker>,
        file: KtFile,
    ): Collection<ResolveTestCaseContext<KtReference?>> = carets.flatMap<CaretMarker, ResolveTestCaseContext<KtReference?>> { caret ->
        val marker = caret.fullTag
        val contexts: List<ResolveTestCaseContext<KtReference?>> = findReferencesAtCaret(file, caret.offset).map { reference ->

) : Project({
    id(asDocsTestId(model, os))
    name = "Docs Test - ${testJava.version.name.toCapitalized()} ${os.asName()}"
}) {
    val docsTests: List<BaseGradleBuildType>

    init {
        docsTests = testTypes.flatMap {
            listOf(
                DocsTest(model, stage, os, testJava, 1, it, INCLUDE, listOf("org.gradle.docs.samples.Bucket1SnippetsTest=docsTest")),

            .trace
        val document = languageModel.toDocument()
        val resolution = resolutionContainer(analysisSchema, trace, document)
        return documentChecks.flatMap { it.detectFailures(document, resolution) }
    }

    private
    val documentChecks = listOf(SettingsBlocksCheck)

    private
    val pluginManagementSchema = pluginManagementEvaluationSchema()

        if (!context.isIncrementalExecution()) {
            if (work.shouldCleanupOutputsOnNonIncrementalExecution()) {
                boolean hasOverlappingOutputs = context.getBeforeExecutionState()
                    .flatMap(BeforeExecutionState::getDetectedOverlappingOutputs)
                    .isPresent();
                if (hasOverlappingOutputs) {
                    cleanupOverlappingOutputs(context, work);
                } else {

                outputDir = project.layout.buildDirectory.dir("root")
            }
            tasks.register("consumer", Consumer) {
                inputDir = producer.flatMap { it.outputDir }
                outputFile = project.layout.buildDirectory.file("output.txt")
            }
        """)

        expect:
        succeeds("consumer", "--info")

        cleanup:

    public DefaultTypeRegistry(
            List<TypeProvider> providers, LanguageRegistry languageRegistry, LegacyArtifactHandlerManager manager) {
        this.types = nonNull(providers, "providers").stream()
                .flatMap(p -> p.provides().stream())
                .collect(Collectors.toMap(Type::id, identity()));
        this.languageRegistry = nonNull(languageRegistry, "languageRegistry");
        this.usedTypes = new ConcurrentHashMap<>();

                .let(providers::fileContents)
                .asText
        }
    }


fun isRunningInstallTask() =
    listOf("install", "installAll")
        .flatMap { listOf(":distributions-full:$it", "distributions-full:$it", it) }
        .any(gradle.startParameter.taskNames::contains)

fun isRunningDocsTestTask() =
    setOf(":docs:docsTest", "docs:docsTest")

     */
    private
    fun findInstrumentedClasses(): Set<String> {
        return instrumentationMetadataDirs
            .map { it.resolve(INSTRUMENTED_CLASSES_FILE) }
            .filter { it.exists() }
            .flatMap { it.readLines() }
            .toSet()
    }

    private
    fun mergeSuperTypes(): Map<String, Set<String>> {
        // Merge all super types files into a single map

    fun since(functionSignature: String): String? {

        val javaFunction = parsedJavaFunctionOf(functionSignature)

        val matchingType = builder.sources
            .flatMap { it.classes }
            .singleOrNull { javaFunction.typeName == it.binaryName }
            ?: throw IllegalArgumentException("Class for function '$functionSignature' not found in since repository! See FunctionSinceRepository.kt")

Factories;;
* link:{javadocPath}/org/gradle/api/provider/Provider.html#map-org.gradle.api.Transformer-[Provider.map(Transformer)].
* link:{javadocPath}/org/gradle/api/provider/Provider.html#flatMap-org.gradle.api.Transformer-[Provider.flatMap(Transformer)].
* link:{javadocPath}/org/gradle/api/file/DirectoryProperty.html#file-java.lang.String-[DirectoryProperty.file(String)]