Scripting: Unify artifacts resolution for partial and non-partial cases

libraries/scripting/dependencies-maven/src/kotlin/script/experimental/dependencies/maven/impl/aether.kt

@@ -39,9 +39,11 @@ import org.eclipse.aether.util.repository.AuthenticationBuilder
 import org.eclipse.aether.util.repository.DefaultMirrorSelector
 import org.eclipse.aether.util.repository.DefaultProxySelector
 import java.io.File
+import kotlin.script.experimental.api.IterableResultsCollector
 import kotlin.script.experimental.api.ResultWithDiagnostics
 import kotlin.script.experimental.api.ScriptDiagnostic
 import kotlin.script.experimental.api.asSuccess
+import kotlin.script.experimental.dependencies.impl.makeResolveFailureResult
 
 val mavenCentral: RemoteRepository = RemoteRepository.Builder("maven central", "default", "https://repo.maven.apache.org/maven2/").build()
 
@@ -153,58 +155,54 @@ internal class AetherResolveSession(
     ): ResultWithDiagnostics<List<File>> {
         if (kind == ResolutionKind.NON_TRANSITIVE) return resolveArtifacts(roots).asSuccess()
 
-        val requests = resolveTree(roots, scope, filter, classifier, extension)
+        val isOptional = kind == ResolutionKind.TRANSITIVE_PARTIAL
+        val requests = resolveTree(roots, scope, isOptional, filter, classifier, extension)
 
-        @Suppress("KotlinConstantConditions")
+        val artifactResults = try {
-        return when (kind) {
+            synchronized(this) {
-            ResolutionKind.TRANSITIVE -> resolveDependencies(requests) {
                 repositorySystem.resolveArtifacts(
                     repositorySystemSession,
                     requests
-                ).toFiles().asSuccess()
+                )
             }
+        } catch (resolutionException: ArtifactResolutionException) {
+            if (isOptional) {
+                resolutionException.results
+            } else {
+                return makeResolveFailureResult(listOf(resolutionException.message.orEmpty()), null, resolutionException)
+            }
+        }
 
-            ResolutionKind.TRANSITIVE_PARTIAL -> resolveDependencies(requests) {
+        return IterableResultsCollector<File>().run {
-                val reports = mutableListOf<ScriptDiagnostic>()
+            for (artifactResult in artifactResults) {
-                val results = mutableListOf<File>()
+                if (artifactResult.isResolved) {
-                for (req in requests) {
+                    addValue(artifactResult.artifact.file)
-                    try {
+                } else {
-                        results.add(
+                    for (exception in artifactResult.exceptions) {
-                            repositorySystem.resolveArtifact(
+                        addDiagnostic(
-                                repositorySystemSession,
-                                req
-                            ).artifact.file
-                        )
-                    } catch (e: ArtifactResolutionException) {
-                        reports.add(
                             ScriptDiagnostic(
                                 ScriptDiagnostic.unspecifiedError,
-                                e.message.orEmpty(),
+                                "Unable to resolve artifact ${artifactResult.request.artifact}",
-                                ScriptDiagnostic.Severity.WARNING,
+                                exception = exception
-                                exception = e
                             )
                         )
                     }
                 }
-
-                ResultWithDiagnostics.Success(results, reports)
-            }
-
-            ResolutionKind.NON_TRANSITIVE -> {
-                error("This statement is not reachable")
             }
+            getResult()
         }
     }
 
     private fun resolveTree(
         roots: List<Artifact>,
         scope: String,
+        isOptional: Boolean,
         filter: DependencyFilter?,
         classifier: String?,
         extension: String?,
     ): Collection<ArtifactRequest> {
         return fetch(
-            request(roots.map { root -> Dependency(root, scope) }),
+            request(roots.map { root -> Dependency(root, scope, isOptional) }),
             { req ->
                 val requestsBuilder = ArtifactRequestBuilder(classifier, extension)
                 val collectionResult = repositorySystem.collectDependencies(repositorySystemSession, req)
@@ -231,22 +229,6 @@ internal class AetherResolveSession(
 
     private fun Collection<ArtifactResult>.toFiles() = map { it.artifact.file }
 
-    private fun resolveDependencies(
-        requests: Collection<ArtifactRequest>,
-        resolveAction: (Collection<ArtifactRequest>) -> ResultWithDiagnostics<List<File>>
-    ): ResultWithDiagnostics<List<File>> {
-        return fetch(
-            requests,
-            resolveAction
-        ) { _, ex ->
-            DependencyCollectionException(
-                null,
-                ex.message,
-                ex
-            )
-        }
-    }
-
     private fun resolveArtifacts(artifacts: List<Artifact>): List<File> {
         val requests = artifacts.map { artifact ->
             ArtifactRequest(artifact, remotes, "")