wip trying to get klib validation working for supported/unsupported targets...

Author: aSemy

Diff for: modules/bcv-gradle-plugin/src/main/kotlin/tasks/BCVApiGenerateTask.kt

@@ -4,7 +4,10 @@ import dev.adamko.kotlin.binary_compatibility_validator.internal.*
 import dev.adamko.kotlin.binary_compatibility_validator.targets.BCVJvmTarget
 import dev.adamko.kotlin.binary_compatibility_validator.targets.BCVKLibTarget
 import dev.adamko.kotlin.binary_compatibility_validator.targets.BCVTarget
-import dev.adamko.kotlin.binary_compatibility_validator.workers.*
+import dev.adamko.kotlin.binary_compatibility_validator.workers.JvmSignaturesWorker
+import dev.adamko.kotlin.binary_compatibility_validator.workers.KLibInferSignaturesWorker
+import dev.adamko.kotlin.binary_compatibility_validator.workers.KLibMergeWorker
+import dev.adamko.kotlin.binary_compatibility_validator.workers.KLibSignaturesWorker
 import java.io.File
 import javax.inject.Inject
 import org.gradle.api.NamedDomainObjectContainer
@@ -71,17 +74,18 @@ constructor(
 
   @TaskAction
   fun generate() {
-    val workQueue = prepareWorkQueue()
-
     prepareDirectories()
 
-    logger.lifecycle("[$path] got ${targets.size} targets : ${targets.joinToString { it.name }}")
+    val workQueue = prepareWorkQueue()
 
     val enabledTargets = targets.matching { it.enabled.getOrElse(true) }
 
+    logger.lifecycle("[$path] got ${targets.size} targets (${enabledTargets.size} enabled) : ${targets.joinToString { it.name }}")
+
+    val jvmTargets = enabledTargets.withType<BCVJvmTarget>().sorted()
     generateJvmTargets(
       workQueue = workQueue,
-      jvmTargets = enabledTargets.withType<BCVJvmTarget>().sorted(),
+      jvmTargets = jvmTargets,
       outputApiBuildDir = outputApiBuildDir.get().asFile,
     )
 
@@ -90,7 +94,6 @@ constructor(
     val klibTargets = enabledTargets.withType<BCVKLibTarget>()
       .filter { it.klibFile.singleOrNull()?.exists() == true }
       .sorted()
-
     generateKLibTargets(
       workQueue = workQueue,
       klibTargets = klibTargets,
@@ -103,26 +106,19 @@ constructor(
 
 
   private fun prepareWorkQueue(): WorkQueue {
-    fs.delete { delete(temporaryDir) }
-    temporaryDir.mkdirs()
-
     return workers.classLoaderIsolation {
       classpath.from(runtimeClasspath)
     }
   }
 
   private fun prepareDirectories() {
-    val outputApiBuildDir = outputApiBuildDir.get()
     fs.delete { delete(outputApiBuildDir) }
-    outputApiBuildDir.asFile.mkdirs()
+    outputApiBuildDir.get().asFile.mkdirs()
 
-    fs.delete { delete(klibTargetsDir.supported) }
+    fs.delete { delete(workDir) }
+    workDir.mkdirs()
     klibTargetsDir.supported.mkdirs()
-
-    fs.delete { delete(klibTargetsDir.unsupported) }
     klibTargetsDir.unsupported.mkdirs()
-
-    fs.delete { delete(klibTargetsDir.extracted) }
     klibTargetsDir.extracted.mkdirs()
   }
 
@@ -187,7 +183,7 @@ constructor(
   private fun generateKLibTargets(
     workQueue: WorkQueue,
     outputApiBuildDir: File,
-    klibTargets: Collection<BCVKLibTarget>,
+    klibTargets: List<BCVKLibTarget>,
   ) {
     if (klibTargets.isEmpty()) {
       logger.info("[$path] No enabled KLib targets")
@@ -201,19 +197,30 @@ constructor(
     generateSupportedKLibTargets(workQueue, supportedKLibTargets)
     generateUnsupportedKLibTargets(workQueue, unsupportedKLibTargets)
 
-    workQueue.await()
+    val allTargetDumpFiles = buildSet {
+      addAll(klibTargetsDir.supported.walk().filter { it.isFile })
+      addAll(klibTargetsDir.unsupported.walk().filter { it.isFile })
+    }
 
-    val allTargetDumpFiles =
-      klibTargetsDir.supported.walk().filter { it.isFile }.toSet() union
-          klibTargetsDir.unsupported.walk().filter { it.isFile }.toSet()
+    mergeDumpFiles(
+      workQueue = workQueue,
+      allTargetDumpFiles = allTargetDumpFiles,
+      outputApiBuildDir = outputApiBuildDir,
+      targets = klibTargets,
+      strictValidation = strictKLibTargetValidation.get(),
+    )
 
-    mergeDumpFiles(workQueue, allTargetDumpFiles, outputApiBuildDir)
+//    workQueue.extract()
   }
 
   private fun generateSupportedKLibTargets(
     workQueue: WorkQueue,
     supportedKLibTargets: List<BCVKLibTarget>
   ) {
+    if (supportedKLibTargets.isEmpty()) {
+      logger.info("[$path] No supported enabled KLib targets")
+      return
+    }
     logger.lifecycle("[$path] generating ${supportedKLibTargets.size} supported KLib targets : ${supportedKLibTargets.joinToString { it.name }}")
 
     val duration = measureTime {
@@ -233,6 +240,10 @@ constructor(
     workQueue: WorkQueue,
     unsupportedKLibTargets: List<BCVKLibTarget>
   ) {
+    if (unsupportedKLibTargets.isEmpty()) {
+      logger.info("[$path] No unsupported enabled KLib targets")
+      return
+    }
     logger.lifecycle("[$path] generating ${unsupportedKLibTargets.size} unsupported KLib targets : ${unsupportedKLibTargets.joinToString { it.name }}")
 
     val duration = measureTime {
@@ -245,6 +256,7 @@ constructor(
           outputDir = klibTargetsDir.unsupported,
         )
       }
+      workQueue.await()
     }
 
     logger.lifecycle("[$path] finished generating unsupported KLib targets in $duration")
@@ -254,20 +266,26 @@ constructor(
   private fun mergeDumpFiles(
     workQueue: WorkQueue,
     allTargetDumpFiles: Set<File>,
-    outputApiBuildDir: File
+    outputApiBuildDir: File,
+    targets: List<BCVKLibTarget>,
+    strictValidation: Boolean,
   ) {
     logger.lifecycle("[$path] merging ${allTargetDumpFiles.size} dump files : ${allTargetDumpFiles.joinToString { it.name }}")
 
-    workQueue.merge(
-      projectName.get(),
-      targetDumpFiles = allTargetDumpFiles,
-      outputDir = outputApiBuildDir,
-    )
-    workQueue.await()
+    val duration = measureTime {
+      workQueue.merge(
+        projectName.get(),
+        targetDumpFiles = allTargetDumpFiles,
+        outputDir = outputApiBuildDir,
+        supportedTargets = targets.filter { it.supportedByCurrentHost.get() }.map { it.targetName },
+        strictValidation = strictValidation,
+      )
+      workQueue.await()
+    }
 
     if (logger.isLifecycleEnabled) {
       val fileNames = outputApiBuildDir.walk().filter { it.isFile }.toList()
-      logger.lifecycle("[$path] merged ${allTargetDumpFiles.size} dump files : $fileNames")
+      logger.lifecycle("[$path] merged ${allTargetDumpFiles.size} dump files in $duration : $fileNames")
     }
   }
 
@@ -288,8 +306,7 @@ constructor(
 
       this@worker.klib.set(target.klibFile.singleFile)
       this@worker.signatureVersion.set(target.signatureVersion)
-      this@worker.strictValidation.set(target.strictValidation)
-//      [email protected](target.supportedByCurrentHost)
+//      [email protected](target.strictValidation)
 
 //      [email protected](klibTargets)
 
@@ -325,37 +342,45 @@ constructor(
     projectName: String,
     targetDumpFiles: Set<File>,
     outputDir: File,
+    supportedTargets: List<String>,
+    strictValidation: Boolean,
   ) {
     val task = this@BCVApiGenerateTask
 
     @OptIn(BCVInternalApi::class)
     submit(KLibMergeWorker::class) worker@{
-      this@worker.projectName.set(projectName)
+//      [email protected](projectName)
       this@worker.taskPath.set(task.path)
 
-      this@worker.outputApiDir.set(outputDir)
+//      [email protected](outputDir)
+      this@worker.outputApiFile.set(
+        outputDir.resolve("$projectName.klib.api")
+      )
+
+      this@worker.strictValidation.set(strictValidation)
+      this@worker.supportedTargets.set(supportedTargets)
 
       this@worker.targetDumpFiles.from(targetDumpFiles)
     }
   }
 
-  @OptIn(BCVExperimentalApi::class)
-  private fun WorkQueue.extract(
-    target: BCVKLibTarget,
-    targetDumpFiles: Set<File>,
-    outputDir: File,
-  ) {
-    val task = this@BCVApiGenerateTask
-
-    @OptIn(BCVInternalApi::class)
-    submit(KLibExtractWorker::class) worker@{
-      this@worker.taskPath.set(task.path)
-      this@worker.strictValidation.set(target.strictValidation)
-
-//      [email protected]()
-//      [email protected]()
-//      [email protected]()
-    }
-  }
+//  @OptIn(BCVExperimentalApi::class)
+//  private fun WorkQueue.extract(
+//    target: BCVKLibTarget,
+//    targetDumpFiles: Set<File>,
+//    outputDir: File,
+//  ) {
+//    val task = this@BCVApiGenerateTask
+//
+//    @OptIn(BCVInternalApi::class)
+//    submit(KLibExtractWorker::class) worker@{
+//      [email protected](task.path)
+//      [email protected](target.strictValidation)
+//
+////      [email protected]()
+////      [email protected]()
+////      [email protected]()
+//    }
+//  }
   //endregion
 }

Diff for: modules/bcv-gradle-plugin/src/main/kotlin/workers/KLibMergeWorker.kt

@@ -4,47 +4,74 @@ import dev.adamko.kotlin.binary_compatibility_validator.internal.BCVExperimental
 import dev.adamko.kotlin.binary_compatibility_validator.internal.BCVInternalApi
 import java.io.Serializable
 import kotlinx.validation.ExperimentalBCVApi
+import kotlinx.validation.KlibValidationSettings
 import kotlinx.validation.api.klib.KlibDump
+import kotlinx.validation.api.klib.KlibTarget
 import kotlinx.validation.api.klib.saveTo
 import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.logging.Logger
 import org.gradle.api.logging.Logging
 import org.gradle.api.provider.Property
+import org.gradle.api.provider.SetProperty
 import org.gradle.workers.WorkAction
 import org.gradle.workers.WorkParameters
 
 @BCVInternalApi
 @BCVExperimentalApi
 @OptIn(ExperimentalBCVApi::class)
 abstract class KLibMergeWorker : WorkAction<KLibMergeWorker.Parameters> {
+// TODO rename 'Merge' to something that represents 'Merge' and 'Extract'... 'MergeSupported'?
 
   @BCVInternalApi
   interface Parameters : WorkParameters, Serializable {
-    val projectName: Property<String>
+//    val projectName: Property<String>
 
-    val outputApiDir: DirectoryProperty
+    val outputApiFile: RegularFileProperty
 
     val targetDumpFiles: ConfigurableFileCollection
 
+    /** Provider returning targets supported by the host compiler. */
+    val supportedTargets: SetProperty<String>
+
+    /** Refer to [KlibValidationSettings.strictValidation] for details. */
+    val strictValidation: Property<Boolean>
+
     /**
      * [Task path][org.gradle.api.Task.getPath] of the task that invoked this worker,
      * for log messages
      */
     val taskPath: Property<String>
   }
 
+  private val taskPath: String get() = parameters.taskPath.get()
+
   override fun execute() {
+    logger.info("[${taskPath}] merging dump files ${parameters.targetDumpFiles} ")
+
     val sourceFiles = parameters.targetDumpFiles.asFileTree
-    val outputFile = parameters.outputApiDir.get().asFile.resolve(parameters.projectName.get() + ".klib.api")
+//    val outputFile = parameters.outputApiDir.get().asFile.resolve(parameters.projectName.get() + ".klib.api")
+    val outputApiFile = parameters.outputApiFile.get().asFile
+
+
+    val supportedTargets = parameters.supportedTargets.get().map { KlibTarget.parse(it).targetName }
 
     val dump = KlibDump()
 
     sourceFiles.forEach { dumpFile ->
       dump.merge(dumpFile, dumpFile.name.substringBefore(".klib.api"))
     }
 
-    dump.saveTo(outputFile)
+//    // Filter out only unsupported files.
+//    // That ensures that target renaming will be caught and reported as a change.
+//    val unsupportedTargets = dump.targets.filter { it.targetName !in supportedTargets }
+//
+////    if (targetsToRemove.isNotEmpty() && parameters.strictValidation.get()) {
+////      error("Validation could not be performed as some targets are not available and strictValidation mode is enabled")
+////    }
+//    dump.remove(unsupportedTargets)
+
+    dump.saveTo(outputApiFile)
   }
 
   @BCVInternalApi

Diff for: modules/bcv-gradle-plugin/src/main/kotlin/workers/KLibSignaturesWorker.kt

@@ -3,6 +3,7 @@ package dev.adamko.kotlin.binary_compatibility_validator.workers
 import dev.adamko.kotlin.binary_compatibility_validator.internal.BCVExperimentalApi
 import dev.adamko.kotlin.binary_compatibility_validator.internal.BCVInternalApi
 import dev.adamko.kotlin.binary_compatibility_validator.targets.KLibSignatureVersion
+import java.io.File
 import java.io.Serializable
 import kotlinx.validation.ExperimentalBCVApi
 import kotlinx.validation.api.klib.*
@@ -32,7 +33,8 @@ abstract class KLibSignaturesWorker : WorkAction<KLibSignaturesWorker.Parameters
     val ignoredClasses: SetProperty<String>
 
     val signatureVersion: Property<KLibSignatureVersion>
-    val strictValidation: Property<Boolean>
+//    val strictValidation: Property<Boolean>
+    val supportedByCurrentHost: Property<Boolean>
 
     /**
      * [Task path][org.gradle.api.Task.getPath] of the task that invoked this worker,
@@ -45,6 +47,14 @@ abstract class KLibSignaturesWorker : WorkAction<KLibSignaturesWorker.Parameters
     val outputFile = parameters.outputApiDir.asFile.get()
       .resolve("${parameters.targetName.get()}.klib.api")
 
+    dump(outputFile)
+
+//    extract(outputFile)
+  }
+
+  private fun dump(
+    outputAbiFile: File,
+  ) {
     val filters = KLibDumpFilters {
       ignoredClasses += parameters.ignoredClasses.get()
       ignoredPackages += parameters.ignoredPackages.get()
@@ -59,8 +69,28 @@ abstract class KLibSignaturesWorker : WorkAction<KLibSignaturesWorker.Parameters
       configurableTargetName = parameters.targetName.get(),
       filters = filters,
     )
+    dump.saveTo(outputAbiFile)
+  }
+
+  private fun extract(
+    abiFile: File,
+  ) {
+//    val supportedTargets = parameters.supportedTargets.get()
+//    val strictValidation = parameters.strictValidation.getOrElse(false)
 
-    dump.saveTo(outputFile)
+    if (abiFile.length() == 0L) {
+      error("Project ABI file $abiFile is empty")
+    }
+    val dump = KlibDump.from(abiFile)
+    val enabledTarget = KlibTarget.parse(parameters.targetName.get())
+    // Filter out only unsupported files.
+    // That ensures that target renaming will be caught and reported as a change.
+//    val targetsToRemove = dump.targets.filter { it.targetName !in enabledTargets }
+//    if (targetsToRemove.isNotEmpty() && strictValidation) {
+//      error("Validation could not be performed as some targets are not available and strictValidation mode is enabled")
+//    }
+//    dump.remove(targetsToRemove)
+    dump.saveTo(abiFile)
   }
 
   @BCVInternalApi