override val content: Collection<DeclarativeDocument.DocumentNode>
            get() = document.content
                .filter { node -> isTopLevelConventionsCall(node, resolutionContainer) }
                .flatMap { (it as? ElementNode)?.content.orEmpty() }
                .filterIsInstance<ElementNode>()
                .filter { it.name in usedSoftwareTypes }

        override val sourceIdentifier: SourceIdentifier

        val discoveredCollectorDeclarations: List<DependencyCollectorDeclaration> = kClass.memberFunctions
            .filter { function -> hasDependencyCollectorGetterSignature(kClass, function) }
            .flatMap { function ->
                val name = dependencyCollectorNameFromGetterName(function.name)
                expandToOverloads { param ->
                    DependencyCollectorDeclaration(

            is ErrorType -> return emptyList()
            is CapturedType -> return type.constructor.supertypes.flatMap { getUpperBounds(it) }
            is NewCapturedType -> return type.constructor.supertypes.flatMap { getUpperBounds(it) }
            is SimpleType -> {
                val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(type)

        this.delegate = delegate;
    }

    @Override
    protected Optional<HashCode> getPreviousCacheKeyIfApplicable(C context) {
        return context.getChanges()
            .flatMap(changes -> context.getPreviousExecutionState()
                .filter(__ -> changes.getChangeDescriptions().isEmpty())
                .map(PreviousExecutionState::getCacheKey));
    }

    @Override

    public static <T> BindingInitializer<T> combine(List<BindingInitializer<T>> bindingInitializers) {
        Set<Key<?>> deps = bindingInitializers.stream()
                .map(BindingInitializer::getDependencies)
                .flatMap(Collection::stream)
                .collect(toSet());
        return new BindingInitializer<T>(deps) {
            @Override
            public Consumer<T> compile(Function<Key<?>, Supplier<?>> compiler) {

    private val buckets: Map<TestCoverage, List<BuildTypeBucket>> by lazy {
        val uuidToTestCoverage = model.stages.flatMap { it.functionalTests }.associateBy { it.uuid }
        val testCoverageAndBuckets = JSON.parseArray(testBucketsJson.readText()) as JSONArray
        testCoverageAndBuckets.associate { testCoverageAndBucket ->

        val pairs = durations.flatMap { it ->
            val scenarioDurations = it as JSONObject
            val scenario = Scenario.fromTestId(scenarioDurations["scenario"] as String)
            (scenarioDurations["durations"] as JSONArray).flatMap {
                val duration = it as JSONObject
                val testProject = duration["testProject"] as String

    isTransitive = false
    extendsFrom(manifestClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

tasks.jar.configure {
    val classpath = resolveManifestClasspath.flatMap { configuration ->
        configuration.elements.map { classpathDependency ->
            classpathDependency.joinToString(" ") { it.asFile.name }
        }
    }
    manifest.attributes("Class-Path" to classpath)

        )
}

tasks.withType<IntegrationTest>() {
    val argument = objects.newInstance(IntegTestCommandLineArgumentProvider::class.java).apply {
        repoLocation.fileProvider(resolveTestRepo.flatMap { it.elements }.map { it.first().asFile })
        kotlinVersion = libs.kotlinVersion
    }
    jvmArgumentProviders.add(argument)

// Maps from a FunctionDef's name to FunctionDef, for a given FunctionDefLibrary
using FunctionDefMap = gtl::FlatMap<StringPiece, const tensorflow::FunctionDef*,
                                    StringPieceHasher>;

// Maps from a functiondef's name to the corresponding "TFConcreteFunction"
using FlatTensorFunctionMap =
    gtl::FlatMap<std::string, std::unique_ptr<FlatTensorFunction>>;

namespace {