private
fun JApiMethod.isEnumImplicitMethodValueOf(): Boolean {
    return name == "valueOf" && parameters.size == 1 && parameters.first().type == "java.lang.String"
}


private
fun JApiMethod.isEnumImplicitMethodValues(): Boolean {
    return name == "values" && parameters.size == 0

        apiVersion = KotlinVersion.KOTLIN_1_8
        languageVersion = KotlinVersion.KOTLIN_1_8
        jvmTarget = JvmTarget.JVM_1_8
        freeCompilerArgs.addAll(
            "-Xjsr305=strict",
            "-java-parameters",
            "-Xsam-conversions=class",
        )
    }
}


fun CompilerConfiguration.configureKotlinCompilerForGradleBuild() {

    put(
        CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS,

 * limitations under the License.
 */

package gradlebuild.docs;

import dev.adamko.dokkatoo.DokkatooExtension;
import dev.adamko.dokkatoo.dokka.parameters.DokkaSourceLinkSpec;
import dev.adamko.dokkatoo.dokka.parameters.DokkaSourceSetSpec;
import dev.adamko.dokkatoo.dokka.plugins.DokkaHtmlPluginParameters;
import dev.adamko.dokkatoo.formats.DokkatooHtmlPlugin;
import dev.adamko.dokkatoo.tasks.DokkatooGenerateTask;

    val extraBuildScanTags: List<String> = if (isRetry) listOf("RetriedBuild") else emptyList()

    val buildScanTags = model.buildScanTags + listOfNotNull(stage?.id) + extraBuildScanTags
    val parameters = (
        buildToolGradleParameters(daemon, maxParallelForks = maxParallelForks) +
            listOf(extraParameters) +
            buildScanTags.map { buildScanTag(it) } +
            functionalTestParameters(os)

    failureConditions.supportTestRetry = false

    val extraParameters = functionalTestExtraParameters("RerunFlakyTest", os, arch, "%$testJvmVersionParameter%", "%$testJvmVendorParameter%")
    val parameters = (
        buildToolGradleParameters(daemon) +
            listOf(extraParameters) +
            functionalTestParameters(os)
        ).joinToString(separator = " ")

This interface is used to indicate that the exception is caused by a compilation failure. 

        val taskPath = event.descriptor.taskPath
        if (shouldInclude(taskPath)) {
            action(taskPath, event.result)
        }
    }

    protected open fun shouldInclude(taskPath: String): Boolean = parameters.monitoredTaskPaths.get().contains(taskPath)

    abstract fun action(taskPath: String, taskResult: TaskOperationResult)

        gradle.taskGraph.whenReady {
            val buildService: Provider<T> = gradle.sharedServices.registerIfAbsent("${klass.simpleName}-$rootProjectName", klass) {
                parameters.monitoredTaskPaths = allTasks.filter(taskFilter).map { if (isInBuildLogic) ":build-logic${it.path}" else it.path }.toSet()
            }
            gradle.serviceOf<BuildEventsListenerRegistry>().onTaskCompletion(buildService)

        def rule = withContext(new SinceAnnotationMissingRule([:]))
        def jApiMethod = Stub(JApiMethod)
        jApiMethod.name >> implicitMethod
        jApiMethod.jApiClass >> jApiClassifier
        jApiMethod.parameters >> paramTypes.collect { paramStub(it) }

        when:
        sourceFile.text = """
            public enum $TEST_INTERFACE_SIMPLE_NAME {
            }
        """

        then:

            Map<String, Object> parameters = new HashMap<>();
            // NOTE: These parameter names _must_ match the setter names in ReleaseNotesTransformer
            parameters.put("baseCss", getBaseCssFile().get().getAsFile());
            parameters.put("releaseNotesCss", getReleaseNotesCssFile().get().getAsFile());