Exclude coroutine lib from IntelliJ dependency

The IntelliJ dependency does not provide sources for the coroutine
library, which can make it very frustrating to debug / view source code.
We specify our own coroutine library, but IntelliJ doesn't seem to
choose to use it over the IntelliJ library, I assume since the IntelliJ
library is defined first. Using an artifact transform we can filter out
the coroutine jar from the IntelliJ library, though, so the IDE will
only see the dependency we define.

Author: DenWav

build.gradle.kts

@@ -112,6 +112,33 @@ dependencies {
     testRuntimeOnly(libs.junit.entine)
 }
 
+val artifactType = Attribute.of("artifactType", String::class.java)
+val filtered = Attribute.of("filtered", Boolean::class.javaObjectType)
+
+dependencies {
+    attributesSchema {
+        attribute(filtered)
+    }
+    artifactTypes.getByName("jar") {
+        attributes.attribute(filtered, false)
+    }
+
+    registerTransform(Filter::class) {
+        from.attribute(filtered, false).attribute(artifactType, "jar")
+        to.attribute(filtered, true).attribute(artifactType, "jar")
+
+        parameters {
+            ideaVersion.set(providers.gradleProperty("ideaVersion"))
+            ideaVersionName.set(providers.gradleProperty("ideaVersionName"))
+            depsFile.set(layout.projectDirectory.file(".gradle/intellij-deps.json"))
+        }
+    }
+}
+
+configurations.compileClasspath {
+    attributes.attribute(filtered, true)
+}
+
 intellij {
     // IntelliJ IDEA dependency
     version.set(providers.gradleProperty("ideaVersion"))
@@ -240,6 +267,8 @@ idea {
     module {
         generatedSourceDirs.add(file("build/gen"))
         excludeDirs.add(file(intellij.sandboxDir.get()))
+        isDownloadJavadoc = true
+        isDownloadSources = true
     }
 }
 

buildSrc/settings.gradle.kts

@@ -0,0 +1,11 @@
+/*
+ * Minecraft Dev for IntelliJ
+ *
+ * https://minecraftdev.org
+ *
+ * Copyright (c) 2021 minecraft-dev
+ *
+ * MIT License
+ */
+
+rootProject.name = "buildSrc"

buildSrc/src/main/kotlin/Filter.kt

@@ -0,0 +1,102 @@
+/*
+ * Minecraft Dev for IntelliJ
+ *
+ * https://minecraftdev.org
+ *
+ * Copyright (c) 2021 minecraft-dev
+ *
+ * MIT License
+ */
+
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import java.nio.file.Files
+import java.nio.file.Path
+import javax.inject.Inject
+import org.gradle.api.artifacts.transform.CacheableTransform
+import org.gradle.api.artifacts.transform.InputArtifact
+import org.gradle.api.artifacts.transform.TransformAction
+import org.gradle.api.artifacts.transform.TransformOutputs
+import org.gradle.api.artifacts.transform.TransformParameters
+import org.gradle.api.file.FileSystemLocation
+import org.gradle.api.file.ProjectLayout
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+
+abstract class Filter : TransformAction<Filter.Params> {
+    interface Params : TransformParameters {
+        @get:Input
+        val ideaVersion: Property<String>
+        @get:Input
+        val ideaVersionName: Property<String>
+        @get:PathSensitive(PathSensitivity.NONE)
+        @get:InputFile
+        val depsFile: RegularFileProperty
+    }
+
+    @get:PathSensitive(PathSensitivity.NONE)
+    @get:InputArtifact
+    abstract val inputArtifact: Provider<FileSystemLocation>
+
+    @get:Inject
+    abstract val layout: ProjectLayout
+
+    private val deps: List<Dep>?
+
+    init {
+        deps = run {
+            val depsFile = parameters.depsFile.orNull?.asFile ?: return@run null
+            if (!depsFile.exists()) {
+                return@run null
+            }
+
+            val depList: DepList = depsFile.bufferedReader().use { reader ->
+                Gson().fromJson(reader, DepList::class.java)
+            }
+
+            if (
+                parameters.ideaVersion.orNull == depList.intellijVersion &&
+                parameters.ideaVersionName.orNull == depList.intellijVersionName
+            ) {
+                depList.deps
+            } else {
+                null
+            }
+        }
+    }
+
+    override fun transform(outputs: TransformOutputs) {
+        val input = inputArtifact.get().asFile.toPath()
+
+        // exclude the coroutines jar
+        // We include our own - but also IntelliJ's jar breaks sources
+        val inputParts = input.map { it.toString() }
+        if (!inputParts.containsAll(pathParts)) {
+            outputs.file(inputArtifact)
+            return
+        }
+
+        val fileName = inputParts.last()
+        if (fileName.startsWith("kotlinx-coroutines")) {
+            return
+        }
+
+        deps?.forEach { d ->
+            if (fileName == "${d.artifactId}-${d.version}.jar") {
+                return
+            }
+        }
+
+        outputs.file(inputArtifact)
+    }
+
+    companion object {
+        private val pathParts = listOf("com.jetbrains.intellij.idea", "ideaIC", "lib")
+    }
+}

buildSrc/src/main/kotlin/mcdev.gradle.kts

@@ -28,12 +28,9 @@ val jsonFile = file("$projectDir/$fileName")
 val ideaVersion: String by project
 val ideaVersionName: String by project
 
-data class DepList(val intellijVersion: String, val intellijVersionName: String, val deps: List<Dep>)
-data class Dep(val groupId: String, val artifactId: String, val version: String)
-
 if (jsonFile.exists()) {
     val deps: DepList = jsonFile.bufferedReader().use { reader ->
-        Gson().fromJson(reader, object : TypeToken<DepList>() {}.type)
+        Gson().fromJson(reader, DepList::class.java)
     }
     if (ideaVersion != deps.intellijVersion || ideaVersionName != deps.intellijVersionName) {
         println("IntelliJ library sources file definition is out of date, deleting")

buildSrc/src/main/kotlin/util.kt

@@ -95,3 +95,6 @@ fun Project.parser(bnf: String, pack: String): TaskDelegate<JavaExec> {
         )
     }
 }
+
+data class DepList(val intellijVersion: String, val intellijVersionName: String, val deps: List<Dep>)
+data class Dep(val groupId: String, val artifactId: String, val version: String)

gradle/libs.versions.toml

@@ -5,6 +5,7 @@ asm = "9.3"
 
 [libraries]
 coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
+coroutines-jdk8 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8", version.ref = "coroutines" }
 coroutines-swing = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-swing", version.ref = "coroutines" }
 
 templateMakerFabric = "com.extracraftx.minecraft:TemplateMakerFabric:0.4.1"
@@ -34,5 +35,5 @@ junit-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "jun
 junit-entine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" }
 
 [bundles]
-coroutines = ["coroutines-core", "coroutines-swing"]
+coroutines = ["coroutines-core", "coroutines-jdk8", "coroutines-swing"]
 asm = ["asm", "asm-tree", "asm-analysis"]

src/main/kotlin/util/utils.kt

@@ -13,8 +13,10 @@ package com.demonwav.mcdev.util
 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
 import com.intellij.lang.java.lexer.JavaLexer
+import com.intellij.openapi.application.AppUIExecutor
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.ModalityState
+import com.intellij.openapi.application.impl.coroutineDispatchingContext
 import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.command.WriteCommandAction
 import com.intellij.openapi.module.Module
@@ -31,6 +33,8 @@ import com.intellij.pom.java.LanguageLevel
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiFile
 import java.util.Locale
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.runBlocking
 
 inline fun <T : Any?> runWriteTask(crossinline func: () -> T): T {
     return invokeAndWait {
@@ -88,6 +92,10 @@ fun invokeLaterAny(func: () -> Unit) {
     ApplicationManager.getApplication().invokeLater(func, ModalityState.any())
 }
 
+fun <T> edtCoroutineScope(block: suspend CoroutineScope.() -> T): T {
+    return runBlocking(AppUIExecutor.onUiThread().coroutineDispatchingContext(), block)
+}
+
 inline fun <T : Any?> PsiFile.runWriteAction(crossinline func: () -> T) =
     applyWriteAction { func() }
 

src/test/kotlin/framework/EdtInterceptor.kt

@@ -10,8 +10,7 @@
 
 package com.demonwav.mcdev.framework
 
-import com.intellij.openapi.util.Ref
-import com.intellij.testFramework.runInEdtAndWait
+import com.demonwav.mcdev.util.edtCoroutineScope
 import java.lang.reflect.Method
 import org.junit.jupiter.api.extension.ExtensionContext
 import org.junit.jupiter.api.extension.InvocationInterceptor
@@ -51,15 +50,11 @@ class EdtInterceptor : InvocationInterceptor {
             return
         }
 
-        val ref = Ref<Throwable>()
-        runInEdtAndWait {
-            try {
+        val thrown = edtCoroutineScope {
+            runCatching {
                 invocation.proceed()
-            } catch (t: Throwable) {
-                ref.set(t)
-            }
+            }.exceptionOrNull()
         }
-        val thrown = ref.get()
         if (thrown != null) {
             throw thrown
         }