override suspend fun run()

in sources/amper-cli/src/org/jetbrains/amper/tasks/web/WebLinkTask.kt [83:154]
56 lines of code
5 McCabe index (conditional complexity)

    override suspend fun run(
        dependenciesResult: List<TaskResult>,
        executionContext: TaskGraphExecutionContext,
    ): Result {
        val fragments = module.fragments.filter {
            it.platforms.contains(platform) && it.isTest == isTest
        }
        if (fragments.isEmpty()) {
            error("Zero fragments in module ${module.userReadableName} for platform $platform isTest=$isTest")
        }

        val externalKLibs = dependenciesResult
            .filterIsInstance<ResolveExternalDependenciesTask.Result>()
            .flatMap { it.runtimeClasspath } // runtime dependencies including transitive
            .distinct()
            .filterKLibs()
            .toList()

        val includeArtifact = dependenciesResult
            .filterIsInstance<WebCompileKlibTask.Result>()
            .firstOrNull { it.taskName == compileKLibTaskName }
            ?.compiledKlib

        if (includeArtifact == null && isTest) {
            // We may skip linking for test specifically if there's no compiled code in the fragments.
            // Libraries are of no interest here because they can't contain any tests
            logger.info("No test code was found compiled for ${fragments.identificationPhrase()}, skipping linking")
            return Result(
                linkedBinary = null,
            )
        }

        val compileKLibDependencies = dependenciesResult
            .filterIsInstance<WebCompileKlibTask.Result>()
            .filter { it.taskName != compileKLibTaskName }

        val compiledKLibs = compileKLibDependencies.mapNotNull { it.compiledKlib }

        val kotlinUserSettings = fragments.singleLeafFragment().serializableKotlinSettings()
        val jdk = jdkProvider.getJdkOrUserError(module.jdkSettings)

        logger.debug("${expectedPlatform.name} link '${module.userReadableName}' -- ${fragments.joinToString(" ") { it.name }}")

        val inputs = compiledKLibs + listOfNotNull(includeArtifact)


        val artifact = incrementalCache.executeForFiles(
            key = taskName.name,
            inputValues = mapOf(
                "kotlin.settings" to Json.encodeToString<KotlinUserSettings>(kotlinUserSettings),
                "task.output.root" to taskOutputRoot.path.pathString,
            ),
            inputFiles = inputs,
        ) {
            cleanDirectory(taskOutputRoot.path)

            val artifactPath = taskOutputRoot.path

            compileSources(
                jdk,
                kotlinUserSettings = kotlinUserSettings,
                librariesPaths = externalKLibs + inputs,
                includeArtifact = includeArtifact,
            )

            listOf(artifactPath)
        }.single()

        return Result(
            linkedBinary = artifact,
        )
    }