Merge branch '2022.1' into 2022.2

Author: DenWav

build.gradle.kts

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jlleitschuh.gradle.ktlint.tasks.BaseKtLintCheckTask
 
 plugins {
-    kotlin("jvm") version "1.7.10"
+    kotlin("jvm") version "1.7.20"
     java
     mcdev
     groovy
@@ -85,6 +85,8 @@ dependencies {
     implementation(libs.mappingIo)
     implementation(libs.bundles.asm)
 
+    implementation(libs.bundles.fuel)
+
     jflex(libs.jflex.lib)
     jflexSkeleton(libs.jflex.skeleton) {
         artifact {

gradle/libs.versions.toml

@@ -1,8 +1,9 @@
 [versions]
-coroutines = "1.6.3"
+coroutines = "1.6.4"
 junit = "5.9.0"
 junit-platform = "1.9.0"
 asm = "9.3"
+fuel = "2.3.1"
 
 [libraries]
 coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
@@ -26,6 +27,9 @@ asm = { module = "org.ow2.asm:asm", version.ref = "asm" }
 asm-tree = { module = "org.ow2.asm:asm-tree", version.ref = "asm" }
 asm-analysis = { module = "org.ow2.asm:asm-analysis", version.ref = "asm" }
 
+fuel = { module = "com.github.kittinunf.fuel:fuel", version.ref = "fuel" }
+fuel-coroutines = { module = "com.github.kittinunf.fuel:fuel-coroutines", version.ref = "fuel" }
+
 # Testing
 test-mockJdk = "org.jetbrains.idea:mock-jdk:1.7-4d76c50"
 test-mixin = "org.spongepowered:mixin:0.8.5"
@@ -39,3 +43,4 @@ junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher
 [bundles]
 coroutines = ["coroutines-core", "coroutines-jdk8", "coroutines-swing"]
 asm = ["asm", "asm-tree", "asm-analysis"]
+fuel = ["fuel", "fuel-coroutines"]

src/main/grammars/AwParser.bnf

@@ -88,20 +88,15 @@ member_name ::= NAME_ELEMENT {
     ]
 }
 
-method_desc ::= OPEN_PAREN argument* CLOSE_PAREN return_value
+method_desc ::= OPEN_PAREN desc_element* CLOSE_PAREN desc_element
 
-field_desc ::= argument
+field_desc ::= desc_element
 
-argument ::= PRIMITIVE | CLASS_VALUE {
+desc_element ::= PRIMITIVE | CLASS_VALUE {
+    mixin= "com.demonwav.mcdev.platform.mcp.aw.psi.mixins.impl.AwDescElementImplMixin"
+    implements= "com.demonwav.mcdev.platform.mcp.aw.psi.mixins.AwDescElementMixin"
     methods=[
         primitive="PRIMITIVE"
         classValue="CLASS_VALUE"
     ]
-}
-
-return_value ::= PRIMITIVE | CLASS_VALUE {
-    methods=[
-        primitive="PRIMITIVE"
-        classValue="CLASS_VALUE"
-    ]
-}
+}

src/main/kotlin/creator/PlatformVersion.kt

@@ -11,28 +11,39 @@
 package com.demonwav.mcdev.creator
 
 import com.demonwav.mcdev.platform.PlatformType
-import com.demonwav.mcdev.util.ProxyHttpConnectionFactory
+import com.demonwav.mcdev.update.PluginUtil
 import com.demonwav.mcdev.util.fromJson
+import com.github.kittinunf.fuel.core.FuelManager
+import com.github.kittinunf.fuel.core.requests.suspendable
+import com.github.kittinunf.fuel.coroutines.awaitString
 import com.google.gson.Gson
 import com.intellij.openapi.diagnostic.Attachment
 import com.intellij.openapi.diagnostic.Logger
+import com.intellij.util.proxy.CommonProxy
 import java.io.IOException
+import java.net.Proxy
+import java.net.URI
 import javax.swing.JComboBox
+import kotlin.reflect.KClass
 
-private const val cloudflareBaseUrl = "https://minecraftdev.org/versions/"
-private const val githubBaseUrl = "https://raw.githubusercontent.com/minecraft-dev/minecraftdev.org/master/versions/"
+private const val CLOUDFLARE_BASE_URL = "https://minecraftdev.org/versions/"
+private const val GITHUB_BASE_URL = "https://raw.githubusercontent.com/minecraft-dev/minecraftdev.org/master/versions/"
 
 val PLATFORM_VERSION_LOGGER = Logger.getInstance("MDev.PlatformVersion")
 
-fun getVersionSelector(type: PlatformType): PlatformVersion {
+suspend fun getVersionSelector(type: PlatformType): PlatformVersion {
     val versionJson = type.versionJson ?: throw UnsupportedOperationException("Incorrect platform type: $type")
     return getVersionJson(versionJson)
 }
 
-inline fun <reified T : Any> getVersionJson(path: String): T {
+suspend inline fun <reified T : Any> getVersionJson(path: String): T {
+    return getVersionJson(path, T::class)
+}
+
+suspend fun <T : Any> getVersionJson(path: String, type: KClass<T>): T {
     val text = getText(path)
     try {
-        return Gson().fromJson(text)
+        return Gson().fromJson(text, type)
     } catch (e: Exception) {
         val attachment = Attachment("JSON Document", text)
         attachment.isIncluded = true
@@ -41,32 +52,45 @@ inline fun <reified T : Any> getVersionJson(path: String): T {
     }
 }
 
-fun getText(path: String): String {
+suspend fun getText(path: String): String {
     return try {
         // attempt cloudflare
-        doCall(cloudflareBaseUrl + path)
+        doCall(CLOUDFLARE_BASE_URL + path)
     } catch (e: IOException) {
-        PLATFORM_VERSION_LOGGER.warn("Failed to reach cloudflare URL ${cloudflareBaseUrl + path}", e)
+        PLATFORM_VERSION_LOGGER.warn("Failed to reach cloudflare URL ${CLOUDFLARE_BASE_URL + path}", e)
         // if that fails, attempt github
         try {
-            doCall(githubBaseUrl + path)
+            doCall(GITHUB_BASE_URL + path)
         } catch (e: IOException) {
-            PLATFORM_VERSION_LOGGER.warn("Failed to reach fallback GitHub URL ${githubBaseUrl + path}", e)
+            PLATFORM_VERSION_LOGGER.warn("Failed to reach fallback GitHub URL ${GITHUB_BASE_URL + path}", e)
             throw e
         }
     }
 }
 
-private fun doCall(urlText: String): String {
-    val connection = ProxyHttpConnectionFactory.openHttpConnection(urlText)
+private suspend fun doCall(urlText: String): String {
+    val manager = FuelManager()
+    manager.proxy = selectProxy(urlText)
+
+    return manager.get(urlText)
+        .header("User-Agent", "github_org/minecraft-dev/${PluginUtil.pluginVersion}")
+        .header("Accepts", "application/json")
+        .suspendable()
+        .awaitString()
+}
 
-    connection.setRequestProperty(
-        "User-Agent",
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) " +
-            "Chrome/72.0.3626.121 Safari/537.36"
-    )
+fun selectProxy(urlText: String): Proxy? {
+    val uri = URI(urlText)
+    val url = uri.toURL()
 
-    return connection.inputStream.use { stream -> stream.reader().use { it.readText() } }
+    val proxies = CommonProxy.getInstance().select(uri)
+    for (proxy in proxies) {
+        try {
+            url.openConnection(proxy)
+            return proxy
+        } catch (_: IOException) {}
+    }
+    return null
 }
 
 data class PlatformVersion(var versions: List<String>, var selectedIndex: Int) {

src/main/kotlin/creator/buildsystem/maven/maven-steps.kt

@@ -40,6 +40,7 @@ import java.nio.file.Path
 import java.nio.file.StandardOpenOption.CREATE
 import java.nio.file.StandardOpenOption.TRUNCATE_EXISTING
 import java.nio.file.StandardOpenOption.WRITE
+import kotlinx.coroutines.runBlocking
 import org.jetbrains.idea.maven.dom.model.MavenDomProjectModel
 import org.jetbrains.idea.maven.execution.MavenRunConfigurationType
 import org.jetbrains.idea.maven.execution.MavenRunnerParameters
@@ -103,7 +104,9 @@ class BasicMavenStep(
 
     companion object {
         val pluginVersions by lazy {
-            getVersionJson<Map<String, String>>("maven.json")
+            runBlocking {
+                getVersionJson<Map<String, String>>("maven.json")
+            }
         }
 
         private val defaultParts = listOf(setupDirs(), setupCore(), setupName(), setupInfo(), setupDependencies())

src/main/kotlin/insight/ListenerLineMarkerProvider.kt

@@ -41,9 +41,19 @@ class ListenerLineMarkerProvider : LineMarkerProviderDescriptor() {
             return null
         }
 
-        val identifier = element.toUElementOfType<UIdentifier>() ?: return null
-        if (identifier.uastParent !is UMethod || identifier.uastEventListener == null) {
-            return null
+        try {
+            val identifier = element.toUElementOfType<UIdentifier>() ?: return null
+            if (identifier.uastParent !is UMethod || identifier.uastEventListener == null) {
+                return null
+            }
+        } catch (e: Exception) {
+            // Kotlin plugin is buggy and can throw exceptions here
+            // We do the check like this because we don't actually have this class on the classpath
+            if (e.javaClass.name == "org.jetbrains.kotlin.idea.caches.resolve.KotlinIdeaResolutionException") {
+                return null
+            }
+            // Don't swallow unexpected errors
+            throw e
         }
 
         // By this point, we can guarantee that the action of "go to declaration" will work

src/main/kotlin/inspection/IsCancelled.kt

@@ -24,7 +24,7 @@ class IsCancelled(
         this.buildFix = object : InspectionGadgetsFix() {
             override fun doFix(project: Project, descriptor: ProblemDescriptor) = fix(descriptor)
             override fun getName() = "Simplify"
-            override fun getFamilyName() = "Useless IsCancelled Check"
+            override fun getFamilyName() = "Useless isCancelled check"
         }
     }
 }

src/main/kotlin/inspection/IsCancelledInspection.kt

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nls
 
 class IsCancelledInspection : BaseInspection() {
     @Nls
-    override fun getDisplayName() = "Useless event is cancelled check"
+    override fun getDisplayName() = "Useless event isCancelled check"
 
     override fun getStaticDescription(): String = "Reports useless event cancellation checks"
 

src/main/kotlin/platform/architectury/creator/ArchitecturyProjectSettingsWizard.kt

@@ -22,7 +22,9 @@ import com.demonwav.mcdev.platform.architectury.version.FabricVersion
 import com.demonwav.mcdev.platform.forge.version.ForgeVersion
 import com.demonwav.mcdev.util.License
 import com.demonwav.mcdev.util.SemanticVersion
+import com.demonwav.mcdev.util.asyncIO
 import com.demonwav.mcdev.util.modUpdateStep
+import com.intellij.openapi.diagnostic.Logger
 import com.intellij.ui.CollectionComboBoxModel
 import com.intellij.ui.EnumComboBoxModel
 import java.awt.event.ActionListener
@@ -37,7 +39,7 @@ import kotlin.math.min
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.swing.Swing
@@ -234,6 +236,7 @@ class ArchitecturyProjectSettingsWizard(private val creator: MinecraftProjectCre
                 updateMcForm(data)
             }
         } catch (e: Exception) {
+            LOGGER.error("Failed to update versions form", e)
             error()
         }
 
@@ -250,9 +253,9 @@ class ArchitecturyProjectSettingsWizard(private val creator: MinecraftProjectCre
     }
 
     private suspend fun downloadVersions() = coroutineScope {
-        val fabricVersionJob = async(Dispatchers.IO) { FabricVersion.downloadData() }
-        val forgeVersionJob = async(Dispatchers.IO) { ForgeVersion.downloadData() }
-        val architecturyApiVersionJob = async(Dispatchers.IO) { ArchitecturyVersion.downloadData() }
+        val fabricVersionJob = asyncIO { FabricVersion.downloadData() }
+        val forgeVersionJob = asyncIO { ForgeVersion.downloadData() }
+        val architecturyApiVersionJob = asyncIO { ArchitecturyVersion.downloadData() }
 
         versions = ArchitecturyVersions(
             fabricVersionJob.await() ?: return@coroutineScope,
@@ -262,29 +265,42 @@ class ArchitecturyProjectSettingsWizard(private val creator: MinecraftProjectCre
     }
 
     private suspend fun updateForm(): Data? = coroutineScope {
-        val vers = versions ?: return@coroutineScope null
+        try {
+            val vers = versions ?: return@coroutineScope null
 
-        val selectedVersion = version ?: vers.forgeVersion.sortedMcVersions.firstOrNull() ?: return@coroutineScope null
+            val selectedVersion = version ?: vers.forgeVersion.sortedMcVersions.firstOrNull()
+                ?: return@coroutineScope null
 
-        val fabricVersionsJob = async(Dispatchers.IO) { vers.fabricVersion.getFabricVersions(selectedVersion) }
-        val forgeVersionsJob = async(Dispatchers.IO) { vers.forgeVersion.getForgeVersions(selectedVersion) }
-        val fabricApiVersionsJob = async(Dispatchers.IO) { vers.fabricVersion.getFabricApiVersions(selectedVersion) }
-        val architecturyApiVersionsJob = async(Dispatchers.IO) {
-            vers.architecturyVersion.getArchitecturyVersions(
-                selectedVersion
-            )
-        }
+            val fabricVersionsJob = asyncIO { vers.fabricVersion.getFabricVersions(selectedVersion) }
+            val forgeVersionsJob = asyncIO { vers.forgeVersion.getForgeVersions(selectedVersion) }
+            val fabricApiVersionsJob = asyncIO { vers.fabricVersion.getFabricApiVersions(selectedVersion) }
+            val architecturyApiVersionsJob = asyncIO {
+                vers.architecturyVersion.getArchitecturyVersions(selectedVersion)
+            }
 
-        val fabricVersions = fabricVersionsJob.await()
-        val forgeVersions = forgeVersionsJob.await()
-        val fabricApiVersions = fabricApiVersionsJob.await()
-        val architecturyApiVersions = architecturyApiVersionsJob.await()
+            // awaitAll is better than calling .await() individually
+            val (
+                fabricVersions,
+                forgeVersions,
+                fabricApiVersions,
+                architecturyApiVersions,
+            ) = listOf(
+                fabricVersionsJob,
+                forgeVersionsJob,
+                fabricApiVersionsJob,
+                architecturyApiVersionsJob
+            ).awaitAll()
 
-        val data = Data(0, fabricVersions, 0, forgeVersions, 0, fabricApiVersions, 0, architecturyApiVersions, 0)
+            val data = Data(0, fabricVersions, 0, forgeVersions, 0, fabricApiVersions, 0, architecturyApiVersions, 0)
 
-        mcVersionUpdate(data)
+            mcVersionUpdate(data)
 
-        return@coroutineScope data
+            return@coroutineScope data
+        } catch (e: Exception) {
+            // log error manually - something is weird about intellij & coroutine exception handling
+            LOGGER.error("Error while updating Architectury form version fields", e)
+            return@coroutineScope null
+        }
     }
 
     private fun updateMcForm(data: Data) {
@@ -293,9 +309,16 @@ class ArchitecturyProjectSettingsWizard(private val creator: MinecraftProjectCre
         minecraftVersionBox.removeActionListener(minecraftBoxActionListener)
         minecraftVersionBox.removeAllItems()
 
-        minecraftVersionBox.model = CollectionComboBoxModel(
-            vers.forgeVersion.sortedMcVersions.filter { it >= SemanticVersion.release(1, 16) }
-        )
+        // make copy, so the next 2 operations don't mess up the map
+        val mcVersions = vers.architecturyVersion.versions.keys.toCollection(LinkedHashSet())
+        mcVersions.retainAll(vers.forgeVersion.sortedMcVersions.toSet())
+        // Fabric also targets preview versions which aren't semver
+        // The other option would be to try to parse all of them and catching any exceptions
+        // But exceptions are slow, so this should be more efficient
+        val fabricMcVersions = vers.fabricVersion.versions.minecraftVersions.mapTo(HashSet()) { it.name }
+        mcVersions.retainAll { fabricMcVersions.contains(it.toString()) }
+
+        minecraftVersionBox.model = CollectionComboBoxModel(mcVersions.sortedDescending())
         minecraftVersionBox.selectedIndex = data.mcSelectedIndex
         minecraftVersionBox.addActionListener(minecraftBoxActionListener)
     }
@@ -311,4 +334,8 @@ class ArchitecturyProjectSettingsWizard(private val creator: MinecraftProjectCre
         val architecturyApiVersions: List<SemanticVersion>,
         val architecturyApiSelectedIndex: Int
     )
+
+    companion object {
+        val LOGGER = Logger.getInstance(ArchitecturyProjectSettingsWizard::class.java)
+    }
 }