Handle InvocationTargetException exception explicitly in DokkaBootstrap

dokka-runners/dokka-gradle-plugin/src/main/kotlin/internal/dokkaBootstrapFactory.kt

@@ -9,45 +9,55 @@ import org.jetbrains.dokka.DokkaBootstrapImpl
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.toCompactJsonString
 import java.io.File
+import java.lang.reflect.InvocationTargetException
 import java.net.URLClassLoader
 import java.util.concurrent.atomic.AtomicReference
 import java.util.function.BiConsumer
 import kotlin.reflect.KClass
 
 internal fun DokkaBootstrap(classpath: Set<File>, bootstrapClass: KClass<out DokkaBootstrap>): DokkaBootstrap {
-    val runtimeClassLoader = URLClassLoader(
+    return DokkaBootstrapProxy(classpath, bootstrapClass)
+}
+
+private class DokkaBootstrapProxy(
+    classpath: Set<File>,
+    bootstrapClass: KClass<out DokkaBootstrap>
+) : DokkaBootstrap {
+    private val runtimeClassLoader = URLClassLoader(
         classpath.map { it.toURI().toURL() }.toTypedArray(),
         ClassLoader.getSystemClassLoader().parent
     )
 
-    val runtimeClassloaderBootstrapClass = runtimeClassLoader.loadClass(bootstrapClass.qualifiedName)
-    val runtimeClassloaderBootstrapInstance = runtimeClassloaderBootstrapClass.constructors.first().newInstance()
+    private val runtimeClassloaderBootstrapClass = runtimeClassLoader.loadClass(bootstrapClass.qualifiedName)
+    private val runtimeClassloaderBootstrapInstance =
+        runtimeClassloaderBootstrapClass.constructors.first().newInstance()
 
-    return object : DokkaBootstrap {
-        override fun configure(
-            serializedConfigurationJSON: String,
-            logger: BiConsumer<String, String>
-        ) {
-            val configureMethod = runtimeClassloaderBootstrapClass.getMethod(
-                "configure",
-                String::class.java,
-                BiConsumer::class.java // Use java.util.function.BiConsumer from *your* loader
-            )
-            configureMethod.invoke(
-                runtimeClassloaderBootstrapInstance,
-                serializedConfigurationJSON,
-                logger
-            )
-        }
+    private fun invokeMethod(
+        name: String,
+        parameterTypes: Array<Class<*>>,
+        args: Array<Any?>
+    ): Any? = try {
+        runtimeClassloaderBootstrapClass
+            .getMethod(name, *parameterTypes)
+            .invoke(runtimeClassloaderBootstrapInstance, *args)
+    } catch (e: InvocationTargetException) {
+        throw e.targetException
+    }
 
-        override fun generate() {
-            val generateMethod = runtimeClassloaderBootstrapClass.getMethod(
-                "generate",
-            )
-            generateMethod.invoke(
-                runtimeClassloaderBootstrapInstance
-            )
-        }
+    override fun configure(serializedConfigurationJSON: String, logger: BiConsumer<String, String>) {
+        invokeMethod(
+            name = "configure",
+            parameterTypes = arrayOf(String::class.java, BiConsumer::class.java),
+            args = arrayOf(serializedConfigurationJSON, logger)
+        )
+    }
+
+    override fun generate() {
+        invokeMethod(
+            name = "generate",
+            parameterTypes = emptyArray(),
+            args = emptyArray()
+        )
     }
 }
 

dokka-runners/dokka-gradle-plugin/src/testFunctional/kotlin/DokkaGeneratorFailureTest.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2014-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.gradle
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.string.shouldContain
+import org.jetbrains.dokka.gradle.internal.DokkaConstants.DOKKA_VERSION
+import org.jetbrains.dokka.gradle.utils.*
+
+class DokkaGeneratorFailureTest : FunSpec({
+    context("DokkaGenerator failure:") {
+        val project = gradleKtsProjectTest("dokka-generator-failure") {
+            buildGradleKts = """
+                |plugins {
+                |    kotlin("jvm") version embeddedKotlinVersion
+                |    id("org.jetbrains.dokka") version "$DOKKA_VERSION"
+                |}
+                |
+                |dokka {
+                |  dokkaSourceSets.configureEach {
+                |    suppress = false // to enable documentation for `test` source set
+                |    sourceRoots.from("src/shared/kotlin") // causes an error in Dokka generator checker
+                |  }
+                |}
+                |
+                """.trimMargin()
+
+            createKotlinFile("src/main/kotlin/Main.kt", "class Main")
+            createKotlinFile("src/test/kotlin/Test.kt", "class Test")
+            createKotlinFile("src/shared/kotlin/Shared.kt", "class Shared")
+        }
+
+        test("expect failure message from checkers to be shown by default") {
+            project.runner
+                .addArguments(
+                    ":dokkaGenerateModuleHtml",
+                    "--rerun",
+                )
+                .buildAndFail {
+                    output shouldContain "Pre-generation validity check failed"
+                    output shouldContain "Source sets 'java' and 'javaTest' have the common source roots"
+                }
+
+            project.runner
+                .addArguments(
+                    ":dokkaGeneratePublicationHtml",
+                    "--rerun",
+                )
+                .buildAndFail {
+                    output shouldContain "Pre-generation validity check failed"
+                    output shouldContain "Source sets 'java' and 'javaTest' have the common source roots"
+                }
+        }
+    }
+})