Merge branch '2022.3' into 2023.1

Author: RedNesto

build.gradle.kts

@@ -33,7 +33,7 @@ plugins {
     mcdev
     groovy
     idea
-    id("org.jetbrains.intellij") version "1.13.2"
+    id("org.jetbrains.intellij") version "1.14.1"
     id("org.cadixdev.licenser")
     id("org.jlleitschuh.gradle.ktlint") version "10.3.0"
 }

gradle.properties

@@ -24,7 +24,7 @@ kotlin.code.style=official
 ideaVersion = 2023.1
 ideaVersionName = 2023.1
 
-coreVersion = 1.6.5
+coreVersion = 1.6.6
 downloadIdeaSources = true
 
 pluginTomlVersion = 231.8109.1

readme.md

@@ -35,7 +35,7 @@ Minecraft Development for IntelliJ
     </tr>
 </table>
 
-Info and Documentation [![Current Release](https://img.shields.io/badge/release-1.6.5-orange.svg?style=flat-square)](https://plugins.jetbrains.com/plugin/8327)
+Info and Documentation [![Current Release](https://img.shields.io/badge/release-1.6.6-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/platform/fabric/inspection/FabricEntrypointsInspection.kt

@@ -0,0 +1,151 @@
+/*
+ * Minecraft Development for IntelliJ
+ *
+ * https://mcdev.io/
+ *
+ * Copyright (C) 2023 minecraft-dev
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, version 3.0 only.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.demonwav.mcdev.platform.fabric.inspection
+
+import com.demonwav.mcdev.platform.fabric.reference.EntryPointReference
+import com.demonwav.mcdev.platform.fabric.util.FabricConstants
+import com.intellij.codeInspection.InspectionManager
+import com.intellij.codeInspection.LocalInspectionTool
+import com.intellij.codeInspection.ProblemDescriptor
+import com.intellij.codeInspection.ProblemHighlightType
+import com.intellij.codeInspection.ProblemsHolder
+import com.intellij.json.psi.JsonElementVisitor
+import com.intellij.json.psi.JsonProperty
+import com.intellij.json.psi.JsonStringLiteral
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiClassType
+import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiField
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.PsiModifier
+import com.intellij.psi.util.parentOfType
+
+class FabricEntrypointsInspection : LocalInspectionTool() {
+
+    override fun getStaticDescription() = "Validates entrypoints declared in Fabric mod JSON files."
+
+    override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+        if (holder.file.name == FabricConstants.FABRIC_MOD_JSON) {
+            return Visitor(holder)
+        }
+        return PsiElementVisitor.EMPTY_VISITOR
+    }
+
+    override fun processFile(file: PsiFile, manager: InspectionManager): List<ProblemDescriptor> {
+        if (file.name == FabricConstants.FABRIC_MOD_JSON) {
+            return super.processFile(file, manager)
+        }
+        return emptyList()
+    }
+
+    private class Visitor(private val holder: ProblemsHolder) : JsonElementVisitor() {
+
+        override fun visitStringLiteral(literal: JsonStringLiteral) {
+            for (reference in literal.references) {
+                if (reference !is EntryPointReference.Reference) {
+                    continue
+                }
+
+                val resolved = reference.multiResolve(false)
+                if (resolved.size > 1) {
+                    holder.registerProblem(
+                        literal,
+                        "Ambiguous member reference",
+                        ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
+                        reference.rangeInElement,
+                    )
+                }
+
+                val element = resolved.singleOrNull()?.element
+                when {
+                    element is PsiClass && !literal.text.contains("::") -> {
+                        val propertyKey = literal.parentOfType<JsonProperty>()?.name
+                        val expectedType = propertyKey?.let { FabricConstants.ENTRYPOINT_BY_TYPE[it] }
+                        if (propertyKey != null && expectedType != null &&
+                            !isEntrypointOfCorrectType(element, propertyKey)
+                        ) {
+                            holder.registerProblem(
+                                literal,
+                                "'$propertyKey' entrypoints must implement $expectedType",
+                                ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
+                                reference.rangeInElement,
+                            )
+                        } else if (element.constructors.isNotEmpty() &&
+                            element.constructors.find { !it.hasParameters() } == null
+                        ) {
+                            holder.registerProblem(
+                                literal,
+                                "Entrypoint class must have an empty constructor",
+                                ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
+                                reference.rangeInElement,
+                            )
+                        }
+                    }
+
+                    element is PsiMethod -> {
+                        if (element.hasParameters()) {
+                            holder.registerProblem(
+                                literal,
+                                "Entrypoint method must have no parameters",
+                                ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
+                                reference.rangeInElement,
+                            )
+                        }
+                    }
+
+                    element is PsiField -> {
+                        if (!element.hasModifierProperty(PsiModifier.STATIC)) {
+                            holder.registerProblem(
+                                literal,
+                                "Entrypoint field must be static",
+                                ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
+                                reference.rangeInElement,
+                            )
+                        }
+
+                        val propertyKey = literal.parentOfType<JsonProperty>()?.name
+                        val fieldTypeClass = (element.type as? PsiClassType)?.resolve()
+                        val expectedType = propertyKey?.let { FabricConstants.ENTRYPOINT_BY_TYPE[it] }
+                        if (propertyKey != null && fieldTypeClass != null && expectedType != null &&
+                            !isEntrypointOfCorrectType(fieldTypeClass, propertyKey)
+                        ) {
+                            holder.registerProblem(
+                                literal,
+                                "'$propertyKey' entrypoints must be of type $expectedType",
+                                ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
+                                reference.rangeInElement,
+                            )
+                        }
+                    }
+                }
+            }
+        }
+
+        private fun isEntrypointOfCorrectType(element: PsiClass, type: String): Boolean {
+            val entrypointClass = FabricConstants.ENTRYPOINT_BY_TYPE[type]
+                ?: return false
+            val clazz = JavaPsiFacade.getInstance(element.project).findClass(entrypointClass, element.resolveScope)
+            return clazz != null && element.isInheritor(clazz, true)
+        }
+    }
+}

src/main/kotlin/platform/fabric/reference/EntryPointReference.kt

@@ -20,21 +20,28 @@
 
 package com.demonwav.mcdev.platform.fabric.reference
 
+import com.demonwav.mcdev.platform.fabric.util.FabricConstants
+import com.demonwav.mcdev.util.fullQualifiedName
 import com.demonwav.mcdev.util.manipulator
 import com.demonwav.mcdev.util.reference.InspectionReference
+import com.intellij.codeInsight.completion.JavaLookupElementBuilder
 import com.intellij.json.psi.JsonStringLiteral
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiClassType
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementResolveResult
+import com.intellij.psi.PsiField
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiModifier
 import com.intellij.psi.PsiPolyVariantReference
 import com.intellij.psi.PsiReference
 import com.intellij.psi.PsiReferenceBase
 import com.intellij.psi.PsiReferenceProvider
 import com.intellij.psi.ResolveResult
+import com.intellij.psi.search.searches.ClassInheritorsSearch
+import com.intellij.util.ArrayUtil
 import com.intellij.util.IncorrectOperationException
 import com.intellij.util.ProcessingContext
 
@@ -46,8 +53,8 @@ object EntryPointReference : PsiReferenceProvider() {
         val manipulator = element.manipulator ?: return PsiReference.EMPTY_ARRAY
         val range = manipulator.getRangeInElement(element)
         val text = element.text.substring(range.startOffset, range.endOffset)
-        val methodParts = text.split("::", limit = 2)
-        val clazzParts = methodParts[0].split("$", limit = 0)
+        val memberParts = text.split("::", limit = 2)
+        val clazzParts = memberParts[0].split("$", limit = 0)
         val references = mutableListOf<Reference>()
         var cursor = -1
         var innerClassDepth = -1
@@ -64,12 +71,12 @@ object EntryPointReference : PsiReferenceProvider() {
             )
             cursor += clazzPart.length
         }
-        if (methodParts.size == 2) {
+        if (memberParts.size == 2) {
             cursor += 2
             references.add(
                 Reference(
                     element,
-                    range.cutOut(TextRange.from(cursor, methodParts[1].length)),
+                    range.cutOut(TextRange.from(cursor, memberParts[1].length)),
                     innerClassDepth,
                     true,
                 ),
@@ -81,16 +88,16 @@ object EntryPointReference : PsiReferenceProvider() {
     private fun resolveReference(
         element: JsonStringLiteral,
         innerClassDepth: Int,
-        isMethodReference: Boolean,
+        isMemberReference: Boolean,
     ): Array<PsiElement> {
         val strReference = element.value
-        val methodParts = strReference.split("::", limit = 2)
+        val memberParts = strReference.split("::", limit = 2)
         // split at dollar sign for inner class evaluation
-        val clazzParts = methodParts[0].split("$", limit = 0)
+        val clazzParts = memberParts[0].split("$", limit = 0)
         // this case should only happen if someone misuses the method, better protect against it anyways
         if (innerClassDepth >= clazzParts.size ||
             innerClassDepth + 1 < clazzParts.size &&
-            isMethodReference
+            isMemberReference
         ) {
             throw IncorrectOperationException("Invalid reference")
         }
@@ -104,27 +111,63 @@ object EntryPointReference : PsiReferenceProvider() {
             if (inner.contains('.')) return PsiElement.EMPTY_ARRAY
             clazz = clazz.findInnerClassByName(inner, false) ?: return PsiElement.EMPTY_ARRAY
         }
-        return if (isMethodReference) {
-            if (methodParts.size == 1) {
+        return if (isMemberReference) {
+            if (memberParts.size == 1) {
                 throw IncorrectOperationException("Invalid reference")
             }
-            clazz.methods.filter { method ->
-                method.name == methodParts[1] &&
-                    method.hasModifierProperty(PsiModifier.PUBLIC) &&
-                    method.hasModifierProperty(PsiModifier.STATIC)
-            }.toTypedArray()
+
+            val members = mutableListOf<PsiElement>()
+            clazz.fields.filterTo(members) { field ->
+                field.name == memberParts[1] &&
+                    field.hasModifierProperty(PsiModifier.PUBLIC) &&
+                    field.hasModifierProperty(PsiModifier.STATIC)
+            }
+
+            clazz.methods.filterTo(members) { method ->
+                method.name == memberParts[1] &&
+                    method.hasModifierProperty(PsiModifier.PUBLIC)
+            }
+
+            members.toTypedArray()
         } else {
             arrayOf(clazz)
         }
     }
 
     fun isEntryPointReference(reference: PsiReference) = reference is Reference
 
-    private class Reference(
+    fun isValidEntrypointClass(element: PsiClass): Boolean {
+        val psiFacade = JavaPsiFacade.getInstance(element.project)
+        var inheritsEntrypointInterface = false
+        for (entrypoint in FabricConstants.ENTRYPOINTS) {
+            val entrypointClass = psiFacade.findClass(entrypoint, element.resolveScope)
+                ?: continue
+            if (element.isInheritor(entrypointClass, true)) {
+                inheritsEntrypointInterface = true
+                break
+            }
+        }
+        return inheritsEntrypointInterface
+    }
+
+    fun isValidEntrypointField(field: PsiField): Boolean {
+        if (!field.hasModifierProperty(PsiModifier.PUBLIC) || !field.hasModifierProperty(PsiModifier.STATIC)) {
+            return false
+        }
+
+        val fieldTypeClass = (field.type as? PsiClassType)?.resolve()
+        return fieldTypeClass != null && isValidEntrypointClass(fieldTypeClass)
+    }
+
+    fun isValidEntrypointMethod(method: PsiMethod): Boolean {
+        return method.hasModifierProperty(PsiModifier.PUBLIC) && !method.hasParameters()
+    }
+
+    class Reference(
         element: JsonStringLiteral,
         range: TextRange,
         private val innerClassDepth: Int,
-        private val isMethodReference: Boolean,
+        private val isMemberReference: Boolean,
     ) :
         PsiReferenceBase<JsonStringLiteral>(element, range),
         PsiPolyVariantReference,
@@ -134,7 +177,7 @@ object EntryPointReference : PsiReferenceProvider() {
         override val unresolved = resolve() == null
 
         override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> {
-            return resolveReference(element, innerClassDepth, isMethodReference)
+            return resolveReference(element, innerClassDepth, isMemberReference)
                 .map { PsiElementResolveResult(it) }.toTypedArray()
         }
 
@@ -154,14 +197,17 @@ object EntryPointReference : PsiReferenceProvider() {
             val text = element.text.substring(range.startOffset, range.endOffset)
             val parts = text.split("::", limit = 2)
 
-            if (isMethodReference) {
-                val targetMethod = newTarget as? PsiMethod
-                    ?: throw IncorrectOperationException("Cannot target $newTarget")
+            if (isMemberReference) {
+                val newTargetName = when (newTarget) {
+                    is PsiMethod -> newTarget.name
+                    is PsiField -> newTarget.name
+                    else -> throw IncorrectOperationException("Cannot target $newTarget")
+                }
                 if (parts.size == 1) {
                     throw IncorrectOperationException("Invalid reference")
                 }
-                val methodRange = range.cutOut(TextRange.from(parts[0].length + 2, parts[1].length))
-                return manipulator.handleContentChange(element, methodRange, targetMethod.name)
+                val memberRange = range.cutOut(TextRange.from(parts[0].length + 2, parts[1].length))
+                return manipulator.handleContentChange(element, memberRange, newTargetName)
             } else {
                 val targetClass = newTarget as? PsiClass
                     ?: throw IncorrectOperationException("Cannot target $newTarget")
@@ -173,5 +219,39 @@ object EntryPointReference : PsiReferenceProvider() {
                 return manipulator.handleContentChange(element, classRange, targetClass.qualifiedName)
             }
         }
+
+        override fun getVariants(): Array<Any> {
+            val manipulator = element.manipulator
+                ?: return ArrayUtil.EMPTY_OBJECT_ARRAY
+
+            val range = manipulator.getRangeInElement(element)
+            val text = element.text.substring(range.startOffset, range.endOffset)
+            val parts = text.split("::", limit = 2)
+
+            val variants = mutableListOf<Any>()
+            if (!isMemberReference) {
+                val psiFacade = JavaPsiFacade.getInstance(element.project)
+                for (entrypoint in FabricConstants.ENTRYPOINTS) {
+                    val entrypointClass = psiFacade.findClass(entrypoint, element.resolveScope)
+                        ?: continue
+                    ClassInheritorsSearch.search(entrypointClass, true)
+                        .mapNotNullTo(variants) {
+                            val shortName = it.name ?: return@mapNotNullTo null
+                            val fqName = it.fullQualifiedName ?: return@mapNotNullTo null
+                            JavaLookupElementBuilder.forClass(it, fqName, true).withPresentableText(shortName)
+                        }
+                }
+            } else if (parts.size >= 2) {
+                val psiFacade = JavaPsiFacade.getInstance(element.project)
+                val className = parts[0].replace('$', '.')
+                val clazz = psiFacade.findClass(className, element.resolveScope)
+                if (clazz != null) {
+                    clazz.fields.filterTo(variants, ::isValidEntrypointField)
+                    clazz.methods.filterTo(variants, ::isValidEntrypointMethod)
+                }
+            }
+
+            return variants.toTypedArray()
+        }
     }
 }