Merge branch '2020.2' into 2020.3

gradle.properties

@@ -14,7 +14,7 @@ kotlin.code.style=official
 ideaVersion = 2020.3.2
 ideaVersionName = 2020.3
 
-coreVersion = 1.5.12
+coreVersion = 1.5.13
 downloadIdeaSources = true
 
 pluginTomlVersion = 0.2.140.3644-203

readme.md

@@ -40,7 +40,7 @@ Minecraft Development for IntelliJ
     </tr>
 </table>
 
-Info and Documentation [![Current Release](https://img.shields.io/badge/release-1.5.12-orange.svg?style=flat-square)](https://plugins.jetbrains.com/plugin/8327)
+Info and Documentation [![Current Release](https://img.shields.io/badge/release-1.5.13-orange.svg?style=flat-square)](https://plugins.jetbrains.com/plugin/8327)
 ----------------------
 
 <a href="https://discord.gg/j6UNcfr"><img src="https://i.imgur.com/JXu9C1G.png" height="48px"></img></a>

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

@@ -25,7 +25,6 @@ import com.demonwav.mcdev.util.virtualFileOrError
 import com.intellij.codeInsight.actions.ReformatCodeProcessor
 import com.intellij.execution.RunManager
 import com.intellij.ide.ui.UISettings
-import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.progress.ProgressIndicator
 import com.intellij.openapi.project.Project
@@ -41,9 +40,9 @@ import java.nio.file.StandardOpenOption.CREATE
 import java.nio.file.StandardOpenOption.TRUNCATE_EXISTING
 import java.nio.file.StandardOpenOption.WRITE
 import org.jetbrains.plugins.gradle.service.execution.GradleExternalTaskConfigurationType
+import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
 import org.jetbrains.plugins.gradle.service.project.open.canLinkAndRefreshGradleProject
 import org.jetbrains.plugins.gradle.service.project.open.linkAndRefreshGradleProject
-import org.jetbrains.plugins.gradle.util.GradleConstants
 import org.jetbrains.plugins.groovy.GroovyLanguage
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory
@@ -286,12 +285,7 @@ class BasicGradleFinalizerStep(
         val runManager = RunManager.getInstance(project)
         val runConfigName = buildSystem.artifactId + ' ' + task
 
-        val runConfiguration = ExternalSystemRunConfiguration(
-            GradleConstants.SYSTEM_ID,
-            project,
-            gradleType.configurationFactories[0],
-            runConfigName
-        )
+        val runConfiguration = GradleRunConfiguration(project, gradleType.factory, runConfigName)
 
         // Set relevant gradle values
         runConfiguration.settings.externalProjectPath = rootDirectory.toAbsolutePath().toString()
@@ -302,7 +296,7 @@ class BasicGradleFinalizerStep(
 
         val settings = runManager.createConfiguration(
             runConfiguration,
-            GradleExternalTaskConfigurationType.getInstance().configurationFactories.first()
+            gradleType.factory
         )
 
         settings.isActivateToolWindowBeforeRun = true

src/main/kotlin/platform/forge/creator/Fg3Template.kt

@@ -13,6 +13,7 @@ package com.demonwav.mcdev.platform.forge.creator
 import com.demonwav.mcdev.creator.buildsystem.BuildSystem
 import com.demonwav.mcdev.platform.BaseTemplate
 import com.demonwav.mcdev.platform.forge.util.ForgePackDescriptor
+import com.demonwav.mcdev.util.MinecraftTemplates.Companion.FG3_1_17_MAIN_CLASS_TEMPLATE
 import com.demonwav.mcdev.util.MinecraftTemplates.Companion.FG3_BUILD_GRADLE_TEMPLATE
 import com.demonwav.mcdev.util.MinecraftTemplates.Companion.FG3_GRADLE_PROPERTIES_TEMPLATE
 import com.demonwav.mcdev.util.MinecraftTemplates.Companion.FG3_MAIN_CLASS_TEMPLATE
@@ -21,6 +22,7 @@ import com.demonwav.mcdev.util.MinecraftTemplates.Companion.FG3_SUBMODULE_BUILD_
 import com.demonwav.mcdev.util.MinecraftTemplates.Companion.FORGE_MIXINS_JSON_TEMPLATE
 import com.demonwav.mcdev.util.MinecraftTemplates.Companion.MODS_TOML_TEMPLATE
 import com.demonwav.mcdev.util.MinecraftTemplates.Companion.PACK_MCMETA_TEMPLATE
+import com.demonwav.mcdev.util.MinecraftVersions
 import com.demonwav.mcdev.util.SemanticVersion
 import com.demonwav.mcdev.util.toPackageName
 import com.intellij.openapi.project.Project
@@ -45,6 +47,24 @@ object Fg3Template : BaseTemplate() {
         return project.applyTemplate(FG3_MAIN_CLASS_TEMPLATE, props)
     }
 
+    fun apply1_17MainClass(
+        project: Project,
+        buildSystem: BuildSystem,
+        config: ForgeProjectConfig,
+        packageName: String,
+        className: String
+    ): String {
+        val props = mapOf(
+            "PACKAGE_NAME" to packageName,
+            "CLASS_NAME" to className,
+            "ARTIFACT_ID" to buildSystem.artifactId,
+            "MOD_NAME" to config.pluginName,
+            "MOD_VERSION" to buildSystem.version
+        )
+
+        return project.applyTemplate(FG3_1_17_MAIN_CLASS_TEMPLATE, props)
+    }
+
     fun applyBuildGradle(
         project: Project,
         buildSystem: BuildSystem,
@@ -53,15 +73,16 @@ object Fg3Template : BaseTemplate() {
         hasData: Boolean
     ): String {
         val (channel, version) = config.mcpVersion.mcpVersion.split('_', limit = 2)
-        val props = mutableMapOf(
+        val props = mutableMapOf<String, Any>(
             "MOD_NAME" to modName,
             "MCP_CHANNEL" to channel,
             "MCP_VERSION" to version,
             "MCP_MC_VERSION" to config.mcpVersion.mcVersion.toString(),
             "FORGE_VERSION" to config.forgeVersionText,
             "GROUP_ID" to buildSystem.groupId,
             "ARTIFACT_ID" to buildSystem.artifactId,
-            "MOD_VERSION" to buildSystem.version
+            "MOD_VERSION" to buildSystem.version,
+            "JAVA_VERSION" to if (config.mcVersion < MinecraftVersions.MC1_17) 8 else 16
         )
         if (hasData) {
             props["HAS_DATA"] = "true"
@@ -96,13 +117,14 @@ object Fg3Template : BaseTemplate() {
         hasData: Boolean
     ): String {
         val (channel, version) = config.mcpVersion.mcpVersion.split('_', limit = 2)
-        val props = mutableMapOf(
+        val props = mutableMapOf<String, Any>(
             "MOD_NAME" to modName,
             "MCP_CHANNEL" to channel,
             "MCP_VERSION" to version,
             "MCP_MC_VERSION" to config.mcpVersion.mcVersion.toString(),
             "FORGE_VERSION" to config.forgeVersionText,
             "ARTIFACT_ID" to buildSystem.artifactId,
+            "JAVA_VERSION" to if (config.mcVersion < MinecraftVersions.MC1_17) 8 else 16,
             "COMMON_PROJECT_NAME" to buildSystem.commonModuleName
         )
         if (hasData) {

src/main/kotlin/platform/forge/creator/ForgeProjectConfig.kt

@@ -61,7 +61,7 @@ class ForgeProjectConfig : ProjectConfig(), GradleCreator {
         buildSystem: GradleBuildSystem
     ) {
         buildSystem.gradleVersion = if (isFg3(mcVersion, forgeVersion)) {
-            Fg3ProjectCreator.FG4_WRAPPER_VERSION
+            Fg3ProjectCreator.FG5_WRAPPER_VERSION
         } else {
             Fg2ProjectCreator.FG_WRAPPER_VERSION
         }

src/main/kotlin/platform/forge/creator/ForgeProjectCreator.kt

@@ -23,6 +23,7 @@ import com.demonwav.mcdev.creator.buildsystem.gradle.GradleWrapperStep
 import com.demonwav.mcdev.creator.buildsystem.gradle.SimpleGradleSetupStep
 import com.demonwav.mcdev.platform.forge.util.ForgeConstants
 import com.demonwav.mcdev.platform.forge.util.ForgePackDescriptor
+import com.demonwav.mcdev.util.MinecraftVersions
 import com.demonwav.mcdev.util.SemanticVersion
 import com.demonwav.mcdev.util.runGradleTaskAndWait
 import com.demonwav.mcdev.util.runWriteTask
@@ -105,7 +106,11 @@ open class Fg3ProjectCreator(
 
     private fun setupMainClassStep(): BasicJavaClassStep {
         return createJavaClassStep(config.mainClass) { packageName, className ->
-            Fg3Template.applyMainClass(project, buildSystem, config, packageName, className)
+            if (config.mcVersion >= MinecraftVersions.MC1_17) {
+                Fg3Template.apply1_17MainClass(project, buildSystem, config, packageName, className)
+            } else {
+                Fg3Template.applyMainClass(project, buildSystem, config, packageName, className)
+            }
         }
     }
 
@@ -175,7 +180,7 @@ open class Fg3ProjectCreator(
     }
 
     companion object {
-        val FG4_WRAPPER_VERSION = SemanticVersion.release(6, 8, 1)
+        val FG5_WRAPPER_VERSION = SemanticVersion.release(7, 1, 1)
     }
 }
 

src/main/kotlin/platform/forge/creator/ForgeProjectSettingsWizard.kt

@@ -19,9 +19,11 @@ import com.demonwav.mcdev.creator.ValidatedFieldType.LIST
 import com.demonwav.mcdev.creator.ValidatedFieldType.NON_BLANK
 import com.demonwav.mcdev.platform.PlatformType
 import com.demonwav.mcdev.platform.forge.version.ForgeVersion
+import com.demonwav.mcdev.platform.mcp.McpVersionPair
 import com.demonwav.mcdev.platform.mcp.version.McpVersion
 import com.demonwav.mcdev.platform.mcp.version.McpVersionEntry
 import com.demonwav.mcdev.util.License
+import com.demonwav.mcdev.util.MinecraftVersions
 import com.demonwav.mcdev.util.SemanticVersion
 import com.demonwav.mcdev.util.modUpdateStep
 import com.intellij.ui.CollectionComboBoxModel
@@ -171,7 +173,12 @@ class ForgeProjectSettingsWizard(private val creator: MinecraftProjectCreator) :
         conf.setAuthors(this.authorsField.text)
         conf.updateUrl = this.updateUrlField.text
 
-        conf.mcpVersion = (this.mcpVersionBox.selectedItem as McpVersionEntry).versionPair
+        conf.mcVersion = this.version ?: SemanticVersion.release()
+        conf.mcpVersion = if (conf.mcVersion >= MinecraftVersions.MC1_17) {
+            McpVersionPair("official_" + conf.mcVersion, conf.mcVersion)
+        } else {
+            (this.mcpVersionBox.selectedItem as McpVersionEntry).versionPair
+        }
 
         (this.forgeVersionBox.selectedItem as SemanticVersion).let { version ->
             val versionString = version.toString()
@@ -182,7 +189,6 @@ class ForgeProjectSettingsWizard(private val creator: MinecraftProjectCreator) :
 
         conf.mixins = mixinsCheckbox.isSelected
         conf.license = licenseBox.selectedItem as? License ?: License.ALL_RIGHTS_RESERVED
-        conf.mcVersion = this.version ?: SemanticVersion.release()
     }
 
     private fun mcVersionUpdate(data: Data) {

src/main/kotlin/platform/forge/inspections/sideonly/FieldDeclarationSideOnlyInspection.kt

@@ -10,6 +10,7 @@
 
 package com.demonwav.mcdev.platform.forge.inspections.sideonly
 
+import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiClassType
 import com.intellij.psi.PsiField
 import com.siyeh.ig.BaseInspection
@@ -35,10 +36,10 @@ class FieldDeclarationSideOnlyInspection : BaseInspection() {
     }
 
     override fun buildFix(vararg infos: Any): InspectionGadgetsFix? {
-        val field = infos[3] as PsiField
+        val annotation = infos[3] as PsiAnnotation
 
-        return if (field.isWritable) {
-            RemoveAnnotationInspectionGadgetsFix(field, "Remove @SideOnly annotation from field")
+        return if (annotation.isWritable) {
+            RemoveAnnotationInspectionGadgetsFix(annotation, "Remove @SideOnly annotation from field")
         } else {
             null
         }
@@ -53,24 +54,24 @@ class FieldDeclarationSideOnlyInspection : BaseInspection() {
                     return
                 }
 
-                val fieldSide = SideOnlyUtil.checkField(field)
-                if (fieldSide === Side.INVALID) {
+                val (fieldAnnotation, fieldSide) = SideOnlyUtil.checkField(field)
+                if (fieldAnnotation == null || fieldSide === Side.INVALID) {
                     return
                 }
 
-                val classSide = SideOnlyUtil.getSideForClass(psiClass)
+                val (classAnnotation, classSide) = SideOnlyUtil.getSideForClass(psiClass)
 
                 if (fieldSide !== Side.NONE && fieldSide !== classSide) {
-                    if (classSide !== Side.NONE && classSide !== Side.INVALID) {
+                    if (classAnnotation != null && classSide !== Side.NONE && classSide !== Side.INVALID) {
                         registerFieldError(
                             field,
                             Error.CLASS_CROSS_ANNOTATED,
-                            fieldSide.annotation,
-                            classSide.annotation,
-                            field
+                            fieldAnnotation.renderSide(fieldSide),
+                            classAnnotation.renderSide(classSide),
+                            field.getAnnotation(fieldAnnotation.annotationName)
                         )
                     } else if (classSide !== Side.NONE) {
-                        registerFieldError(field, Error.CLASS_UNANNOTATED, fieldSide.annotation, null, field)
+                        registerFieldError(field, Error.CLASS_UNANNOTATED, fieldAnnotation, null, field)
                     }
                 }
 
@@ -85,19 +86,19 @@ class FieldDeclarationSideOnlyInspection : BaseInspection() {
                 val type = field.type as PsiClassType
                 val fieldClass = type.resolve() ?: return
 
-                val fieldClassSide = SideOnlyUtil.getSideForClass(fieldClass)
+                val (fieldClassAnnotation, fieldClassSide) = SideOnlyUtil.getSideForClass(fieldClass)
 
-                if (fieldClassSide === Side.NONE || fieldClassSide === Side.INVALID) {
+                if (fieldClassAnnotation == null || fieldClassSide === Side.NONE || fieldClassSide === Side.INVALID) {
                     return
                 }
 
                 if (fieldClassSide !== fieldSide) {
                     registerFieldError(
                         field,
                         Error.FIELD_CROSS_ANNOTATED,
-                        fieldClassSide.annotation,
-                        fieldSide.annotation,
-                        field
+                        fieldClassAnnotation.renderSide(fieldClassSide),
+                        fieldAnnotation.renderSide(fieldSide),
+                        field.getAnnotation(fieldAnnotation.annotationName)
                     )
                 }
             }

src/main/kotlin/platform/forge/inspections/sideonly/LocalVariableDeclarationSideOnlyInspection.kt

@@ -11,7 +11,7 @@
 package com.demonwav.mcdev.platform.forge.inspections.sideonly
 
 import com.demonwav.mcdev.util.findContainingClass
-import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiClassType
 import com.intellij.psi.PsiLocalVariable
 import com.siyeh.ig.BaseInspection
@@ -34,11 +34,11 @@ class LocalVariableDeclarationSideOnlyInspection : BaseInspection() {
             " or method that does not match the same side."
 
     override fun buildFix(vararg infos: Any): InspectionGadgetsFix? {
-        val variableClass = infos[3] as PsiClass
+        val annotation = infos[3] as PsiAnnotation
 
-        return if (variableClass.isWritable) {
+        return if (annotation.isWritable) {
             RemoveAnnotationInspectionGadgetsFix(
-                variableClass,
+                annotation,
                 "Remove @SideOnly annotation from variable class declaration"
             )
         } else {
@@ -59,30 +59,32 @@ class LocalVariableDeclarationSideOnlyInspection : BaseInspection() {
 
                 val variableClass = type.resolve() ?: return
 
-                val variableSide = SideOnlyUtil.getSideForClass(variableClass)
-                if (variableSide === Side.NONE || variableSide === Side.INVALID) {
+                val (variableAnnotation, variableSide) = SideOnlyUtil.getSideForClass(variableClass)
+                if (variableAnnotation == null || variableSide === Side.NONE || variableSide === Side.INVALID) {
                     return
                 }
 
-                val containingClassSide = SideOnlyUtil.getSideForClass(psiClass)
-                val methodSide = SideOnlyUtil.checkElementInMethod(variable)
+                val (containingClassAnnotation, containingClassSide) = SideOnlyUtil.getSideForClass(psiClass)
+                val (methodAnnotation, methodSide) = SideOnlyUtil.checkElementInMethod(variable)
 
                 var classAnnotated = false
 
-                if (containingClassSide !== Side.NONE && containingClassSide !== Side.INVALID) {
+                if (containingClassAnnotation != null &&
+                    containingClassSide !== Side.NONE && containingClassSide !== Side.INVALID
+                ) {
                     if (variableSide !== containingClassSide) {
                         registerVariableError(
                             variable,
                             Error.VAR_CROSS_ANNOTATED_CLASS,
-                            variableSide.annotation,
-                            containingClassSide.annotation,
-                            variableClass
+                            variableAnnotation.renderSide(variableSide),
+                            containingClassAnnotation.renderSide(containingClassSide),
+                            variableClass.getAnnotation(variableAnnotation.annotationName)
                         )
                     }
                     classAnnotated = true
                 }
 
-                if (methodSide === Side.INVALID) {
+                if (methodAnnotation == null || methodSide === Side.INVALID) {
                     return
                 }
 
@@ -92,18 +94,18 @@ class LocalVariableDeclarationSideOnlyInspection : BaseInspection() {
                             registerVariableError(
                                 variable,
                                 Error.VAR_UNANNOTATED_METHOD,
-                                variableSide.annotation,
-                                methodSide.annotation,
-                                variableClass
+                                variableAnnotation.renderSide(variableSide),
+                                methodAnnotation.renderSide(methodSide),
+                                variableClass.getAnnotation(variableAnnotation.annotationName)
                             )
                         }
                     } else {
                         registerVariableError(
                             variable,
                             Error.VAR_CROSS_ANNOTATED_METHOD,
-                            variableSide.annotation,
-                            methodSide.annotation,
-                            variableClass
+                            variableAnnotation.renderSide(variableSide),
+                            methodAnnotation.renderSide(methodSide),
+                            variableClass.getAnnotation(variableAnnotation.annotationName)
                         )
                     }
                 }