Merge branch 'refs/heads/2023.2' into 2023.3

gradle.properties

@@ -24,7 +24,7 @@ kotlin.code.style=official
 ideaVersion = 2023.3
 ideaVersionName = 2023.3
 
-coreVersion = 1.7.5
+coreVersion = 1.7.6
 downloadIdeaSources = true
 
 pluginTomlVersion = 233.11799.172

readme.md

@@ -23,6 +23,10 @@ Minecraft Development for IntelliJ
         <td align="left">2024.1</td>
         <td align="left"><a href="https://ci.mcdev.io/viewType.html?buildTypeId=MinecraftDev_Nightly_20241"><img src="https://ci.mcdev.io/app/rest/builds/buildType:(id:MinecraftDev_Nightly_20241)/statusIcon.svg" alt="2024.1 Nightly Status" /></a></td>
     </tr>
+    <tr>
+        <td align="left">2024.2</td>
+        <td align="left"><a href="https://ci.mcdev.io/viewType.html?buildTypeId=MinecraftDev_Nightly_20242"><img src="https://ci.mcdev.io/app/rest/builds/buildType:(id:MinecraftDev_Nightly_20242)/statusIcon.svg" alt="2024.2 Nightly Status" /></a></td>
+    </tr>
     <tr>
         <td align="right"><b>OS Tests</b></td>
         <td align="left" colspan="2">
@@ -31,7 +35,7 @@ Minecraft Development for IntelliJ
     </tr>
 </table>
 
-Info and Documentation [![Current Release](https://img.shields.io/badge/release-1.7.5-orange.svg?style=flat-square)](https://plugins.jetbrains.com/plugin/8327)
+Info and Documentation [![Current Release](https://img.shields.io/badge/release-1.7.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/bungeecord/creator/bungee-platforms.kt

@@ -28,6 +28,8 @@ import com.demonwav.mcdev.util.SemanticVersion
 class BungeeMainPlatformStep(parent: BungeePlatformStep) : AbstractBungeePlatformStep(parent, PlatformType.BUNGEECORD) {
     override fun getRepositories(mcVersion: SemanticVersion) = listOf(
         BuildRepository("sonatype", "https://oss.sonatype.org/content/groups/public/"),
+        // Seems to be required since 1.21
+        BuildRepository("Minecraft Libraries", "https://libraries.minecraft.net/"),
     )
 
     override fun getDependencies(mcVersion: SemanticVersion) = listOf(

src/main/kotlin/platform/forge/creator/asset-steps.kt

@@ -108,6 +108,7 @@ class ForgeProjectFilesStep(parent: NewProjectWizardStep) : AbstractLongRunningA
         }
 
         val mainClassTemplate = when {
+            mcVersion >= MinecraftVersions.MC1_20_6 -> MinecraftTemplates.FG3_1_20_6_MAIN_CLASS_TEMPLATE
             mcVersion >= MinecraftVersions.MC1_20 -> MinecraftTemplates.FG3_1_20_MAIN_CLASS_TEMPLATE
             mcVersion >= MinecraftVersions.MC1_19_3 -> MinecraftTemplates.FG3_1_19_3_MAIN_CLASS_TEMPLATE
             mcVersion >= MinecraftVersions.MC1_19 -> MinecraftTemplates.FG3_1_19_MAIN_CLASS_TEMPLATE
@@ -124,6 +125,7 @@ class ForgeProjectFilesStep(parent: NewProjectWizardStep) : AbstractLongRunningA
         )
 
         val configTemplate = when {
+            mcVersion >= MinecraftVersions.MC1_21 -> MinecraftTemplates.FG3_1_21_CONFIG_TEMPLATE
             mcVersion >= MinecraftVersions.MC1_20 -> MinecraftTemplates.FG3_1_20_CONFIG_TEMPLATE
             else -> null
         }

src/main/kotlin/platform/forge/util/ForgePackDescriptor.kt

@@ -55,7 +55,8 @@ data class ForgePackDescriptor(val format: Int, val comment: String) {
         val FORMAT_15 = ForgePackDescriptor(15, "")
         val FORMAT_18 = ForgePackDescriptor(18, "")
         val FORMAT_26 = ForgePackDescriptor(26, "")
-        val FORMAT_41 = ForgePackDescriptor(26, "")
+        val FORMAT_41 = ForgePackDescriptor(41, "")
+        val FORMAT_48 = ForgePackDescriptor(48, "")
 
         // See https://minecraft.gamepedia.com/Tutorials/Creating_a_resource_pack#.22pack_format.22
         fun forMcVersion(version: SemanticVersion): ForgePackDescriptor? = when {
@@ -71,7 +72,8 @@ data class ForgePackDescriptor(val format: Int, val comment: String) {
             version < MinecraftVersions.MC1_20_2 -> FORMAT_15
             version < MinecraftVersions.MC1_20_3 -> FORMAT_18
             version < MinecraftVersions.MC1_20_5 -> FORMAT_26
-            version >= MinecraftVersions.MC1_20_5 -> FORMAT_41
+            version < MinecraftVersions.MC1_21 -> FORMAT_41
+            version >= MinecraftVersions.MC1_21 -> FORMAT_48
             else -> null
         }
     }

src/main/kotlin/platform/mixin/handlers/InjectorAnnotationHandler.kt

@@ -54,19 +54,25 @@ import org.objectweb.asm.tree.MethodNode
 
 abstract class InjectorAnnotationHandler : MixinAnnotationHandler {
     override fun resolveTarget(annotation: PsiAnnotation, targetClass: ClassNode): List<MixinTargetMember> {
-        val targetClassMethods = targetClass.methods ?: return emptyList()
-
         val methodAttr = annotation.findAttributeValue("method")
         val method = methodAttr?.computeStringArray() ?: emptyList()
         val desc = annotation.findAttributeValue("desc")?.findAnnotations() ?: emptyList()
         val selectors = method.mapNotNull { parseMixinSelector(it, methodAttr!!) } +
             desc.mapNotNull { DescSelectorParser.descSelectorFromAnnotation(it) }
 
-        return targetClassMethods.mapNotNull { targetMethod ->
-            if (selectors.any { it.matchMethod(targetMethod, targetClass) }) {
-                MethodTargetMember(targetClass, targetMethod)
-            } else {
-                null
+        val targetClassMethods = selectors.associateWith { selector ->
+            val actualTarget = selector.getCustomOwner(targetClass)
+            (actualTarget to actualTarget.methods)
+        }
+
+        return targetClassMethods.mapNotNull { (selector, pair) ->
+            val (clazz, methods) = pair
+            methods.firstNotNullOfOrNull { method ->
+                if (selector.matchMethod(method, clazz)) {
+                    MethodTargetMember(clazz, method)
+                } else {
+                    null
+                }
             }
         }
     }
@@ -99,7 +105,7 @@ abstract class InjectorAnnotationHandler : MixinAnnotationHandler {
     override fun resolveForNavigation(annotation: PsiAnnotation, targetClass: ClassNode): List<PsiElement> {
         return resolveTarget(annotation, targetClass).flatMap { targetMember ->
             val targetMethod = targetMember as? MethodTargetMember ?: return@flatMap emptyList()
-            resolveForNavigation(annotation, targetClass, targetMethod.classAndMethod.method)
+            resolveForNavigation(annotation, targetMethod.classAndMethod.clazz, targetMethod.classAndMethod.method)
         }
     }
 

src/main/kotlin/platform/mixin/handlers/injectionPoint/AtResolver.kt

@@ -20,6 +20,7 @@
 
 package com.demonwav.mcdev.platform.mixin.handlers.injectionPoint
 
+import com.demonwav.mcdev.platform.mixin.reference.MixinSelector
 import com.demonwav.mcdev.platform.mixin.reference.isMiscDynamicSelector
 import com.demonwav.mcdev.platform.mixin.reference.parseMixinSelector
 import com.demonwav.mcdev.platform.mixin.reference.target.TargetReference
@@ -152,7 +153,7 @@ class AtResolver(
         val collectVisitor = injectionPoint.createCollectVisitor(
             at,
             target,
-            targetClass,
+            getTargetClass(target),
             CollectVisitor.Mode.MATCH_FIRST,
         )
         if (collectVisitor == null) {
@@ -181,7 +182,7 @@ class AtResolver(
         val targetAttr = at.findAttributeValue("target")
         val target = targetAttr?.let { parseMixinSelector(it) }
 
-        val collectVisitor = injectionPoint.createCollectVisitor(at, target, targetClass, mode)
+        val collectVisitor = injectionPoint.createCollectVisitor(at, target, getTargetClass(target), mode)
             ?: return InsnResolutionInfo.Failure()
         collectVisitor.visit(targetMethod)
         val result = collectVisitor.result
@@ -201,7 +202,7 @@ class AtResolver(
 
         // Then attempt to find the corresponding source elements using the navigation visitor
         val targetElement = targetMethod.findSourceElement(
-            targetClass,
+            getTargetClass(target),
             at.project,
             GlobalSearchScope.allScope(at.project),
             canDecompile = true,
@@ -223,16 +224,23 @@ class AtResolver(
 
         // Collect all possible targets
         fun <T : PsiElement> doCollectVariants(injectionPoint: InjectionPoint<T>): List<Any> {
-            val visitor = injectionPoint.createCollectVisitor(at, target, targetClass, CollectVisitor.Mode.COMPLETION)
+            val visitor = injectionPoint.createCollectVisitor(
+                at, target, getTargetClass(target),
+                CollectVisitor.Mode.COMPLETION
+            )
                 ?: return emptyList()
             visitor.visit(targetMethod)
             return visitor.result
                 .mapNotNull { result ->
-                    injectionPoint.createLookup(targetClass, result)?.let { completionHandler(it) }
+                    injectionPoint.createLookup(getTargetClass(target), result)?.let { completionHandler(it) }
                 }
         }
         return doCollectVariants(injectionPoint)
     }
+
+    private fun getTargetClass(selector: MixinSelector?): ClassNode {
+        return selector?.getCustomOwner(targetClass) ?: targetClass
+    }
 }
 
 sealed class InsnResolutionInfo {

src/main/kotlin/platform/mixin/handlers/mixinextras/WrapMethodHandler.kt

@@ -0,0 +1,83 @@
+/*
+ * Minecraft Development for IntelliJ
+ *
+ * https://mcdev.io/
+ *
+ * Copyright (C) 2024 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.mixin.handlers.mixinextras
+
+import com.demonwav.mcdev.platform.mixin.handlers.InjectorAnnotationHandler
+import com.demonwav.mcdev.platform.mixin.handlers.injectionPoint.InsnResolutionInfo
+import com.demonwav.mcdev.platform.mixin.inspection.injector.MethodSignature
+import com.demonwav.mcdev.platform.mixin.inspection.injector.ParameterGroup
+import com.demonwav.mcdev.platform.mixin.util.findSourceElement
+import com.demonwav.mcdev.platform.mixin.util.getGenericReturnType
+import com.demonwav.mcdev.platform.mixin.util.mixinExtrasOperationType
+import com.demonwav.mcdev.util.Parameter
+import com.intellij.psi.PsiAnnotation
+import com.intellij.psi.PsiElement
+import com.intellij.psi.search.GlobalSearchScope
+import org.objectweb.asm.tree.ClassNode
+import org.objectweb.asm.tree.MethodNode
+
+class WrapMethodHandler : InjectorAnnotationHandler() {
+    override fun expectedMethodSignature(
+        annotation: PsiAnnotation,
+        targetClass: ClassNode,
+        targetMethod: MethodNode,
+    ): List<MethodSignature> {
+        val returnType = targetMethod.getGenericReturnType(targetClass, annotation.project)
+
+        return listOf(
+            MethodSignature(
+                listOf(
+                    ParameterGroup(
+                        collectTargetMethodParameters(annotation.project, targetClass, targetMethod) +
+                            Parameter(
+                                "original",
+                                mixinExtrasOperationType(annotation, returnType) ?: return emptyList()
+                            ),
+                    )
+                ),
+                returnType
+            )
+        )
+    }
+
+    override fun isUnresolved(
+        annotation: PsiAnnotation,
+        targetClass: ClassNode,
+        targetMethod: MethodNode
+    ): InsnResolutionInfo.Failure? {
+        // If we've got a target method that's good enough
+        return null
+    }
+
+    override fun resolveForNavigation(
+        annotation: PsiAnnotation,
+        targetClass: ClassNode,
+        targetMethod: MethodNode
+    ): List<PsiElement> {
+        val project = annotation.project
+        return targetMethod.findSourceElement(
+            targetClass,
+            project,
+            GlobalSearchScope.allScope(project),
+            canDecompile = true
+        )?.let(::listOf).orEmpty()
+    }
+}

src/main/kotlin/platform/mixin/handlers/mixinextras/WrapOperationHandler.kt

@@ -21,12 +21,9 @@
 package com.demonwav.mcdev.platform.mixin.handlers.mixinextras
 
 import com.demonwav.mcdev.platform.mixin.inspection.injector.ParameterGroup
-import com.demonwav.mcdev.platform.mixin.util.MixinConstants.MixinExtras.OPERATION
+import com.demonwav.mcdev.platform.mixin.util.mixinExtrasOperationType
 import com.demonwav.mcdev.util.Parameter
-import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiAnnotation
-import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiPrimitiveType
 import com.intellij.psi.PsiType
 import org.objectweb.asm.tree.AbstractInsnNode
 import org.objectweb.asm.tree.ClassNode
@@ -50,21 +47,9 @@ class WrapOperationHandler : MixinExtrasInjectorAnnotationHandler() {
     ): Pair<ParameterGroup, PsiType>? {
         val params = getPsiParameters(insn, targetClass, annotation) ?: return null
         val returnType = getPsiReturnType(insn, annotation) ?: return null
-        val operationType = getOperationType(annotation, returnType) ?: return null
+        val operationType = mixinExtrasOperationType(annotation, returnType) ?: return null
         return ParameterGroup(
             params + Parameter("original", operationType)
         ) to returnType
     }
-
-    private fun getOperationType(context: PsiElement, type: PsiType): PsiType? {
-        val project = context.project
-        val boxedType = if (type is PsiPrimitiveType) {
-            type.getBoxedType(context) ?: return null
-        } else {
-            type
-        }
-
-        return JavaPsiFacade.getElementFactory(project)
-            .createTypeFromText("$OPERATION<${boxedType.canonicalText}>", context)
-    }
 }

src/main/kotlin/platform/mixin/inspection/StaticMemberInspection.kt

@@ -37,7 +37,7 @@ import com.intellij.psi.PsiModifier
 class StaticMemberInspection : MixinInspection() {
 
     override fun getStaticDescription() =
-        "A mixin class does not exist at runtime, and thus having them public does not make sense. " +
+        "A mixin class does not exist at runtime, and thus having them not private does not make sense. " +
             "Make the field/method private instead."
 
     override fun buildVisitor(holder: ProblemsHolder): PsiElementVisitor = Visitor(holder)
@@ -56,7 +56,7 @@ class StaticMemberInspection : MixinInspection() {
             if (isProblematic(member)) {
                 holder.registerProblem(
                     member,
-                    "Public static members are not allowed in Mixin classes",
+                    "Non-private static members are not allowed in Mixin classes",
                     QuickFixFactory.getInstance().createModifierListFix(member, PsiModifier.PRIVATE, true, false),
                 )
             }
@@ -70,7 +70,7 @@ class StaticMemberInspection : MixinInspection() {
 
             val modifiers = member.modifierList!!
 
-            return modifiers.hasModifierProperty(PsiModifier.PUBLIC) &&
+            return !modifiers.hasModifierProperty(PsiModifier.PRIVATE) &&
                 modifiers.hasModifierProperty(PsiModifier.STATIC) &&
                 modifiers.findAnnotation(SHADOW) == null &&
                 modifiers.findAnnotation(OVERWRITE) == null &&

src/main/kotlin/platform/mixin/inspection/mixinextras/WrongOperationParametersInspection.kt

@@ -61,7 +61,9 @@ class WrongOperationParametersInspection : MixinInspection() {
                 PsiField::class.java
             ) ?: return
 
-            if (!containingMethod.hasAnnotation(MixinConstants.MixinExtras.WRAP_OPERATION)) {
+            if (!containingMethod.hasAnnotation(MixinConstants.MixinExtras.WRAP_OPERATION) &&
+                !containingMethod.hasAnnotation(MixinConstants.MixinExtras.WRAP_METHOD)
+            ) {
                 return
             }
 

src/main/kotlin/platform/mixin/reference/AbstractMethodReference.kt

@@ -83,7 +83,9 @@ abstract class AbstractMethodReference : PolyReferenceResolver(), MixinReference
         val stringValue = context.constantStringValue ?: return false
         val targetMethodInfo = parseSelector(stringValue, context) ?: return false
         val targets = getTargets(context) ?: return false
-        return !targets.asSequence().flatMap { it.findMethods(targetMethodInfo) }.any()
+        return !targets.asSequence().flatMap {
+            targetMethodInfo.getCustomOwner(it).findMethods(targetMethodInfo)
+        }.any()
     }
 
     fun getReferenceIfAmbiguous(context: PsiElement): MemberReference? {
@@ -125,7 +127,10 @@ abstract class AbstractMethodReference : PolyReferenceResolver(), MixinReference
         selector: MixinSelector,
     ): Sequence<ClassAndMethodNode> {
         return targets.asSequence()
-            .flatMap { target -> target.findMethods(selector).map { ClassAndMethodNode(target, it) } }
+            .flatMap { target ->
+                val actualTarget = selector.getCustomOwner(target)
+                actualTarget.findMethods(selector).map { ClassAndMethodNode(actualTarget, it) }
+            }
     }
 
     fun resolveIfUnique(context: PsiElement): ClassAndMethodNode? {