Rewrite AtUsageInspection

Removed redundant code and fixes some false positives

Author: RedNesto

src/main/kotlin/platform/mcp/at/AtUsageInspection.kt

@@ -20,24 +20,34 @@
 
 package com.demonwav.mcdev.platform.mcp.at
 
-import com.demonwav.mcdev.facet.MinecraftFacet
-import com.demonwav.mcdev.platform.mcp.McpModuleType
 import com.demonwav.mcdev.platform.mcp.at.gen.psi.AtEntry
-import com.demonwav.mcdev.platform.mcp.at.gen.psi.AtFieldName
-import com.demonwav.mcdev.platform.mcp.at.gen.psi.AtFunction
+import com.demonwav.mcdev.platform.mcp.at.gen.psi.AtTypes
+import com.demonwav.mcdev.util.excludeFileTypes
 import com.intellij.codeInspection.LocalInspectionTool
-import com.intellij.codeInspection.ProblemHighlightType
+import com.intellij.codeInspection.LocalQuickFixOnPsiElement
 import com.intellij.codeInspection.ProblemsHolder
-import com.intellij.openapi.module.ModuleUtilCore
+import com.intellij.codeInspection.util.IntentionFamilyName
+import com.intellij.codeInspection.util.IntentionName
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementVisitor
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiMethod
 import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.search.searches.OverridingMethodsSearch
 import com.intellij.psi.search.searches.ReferencesSearch
+import com.intellij.psi.util.elementType
+import com.intellij.psi.util.siblings
 
 class AtUsageInspection : LocalInspectionTool() {
 
     override fun getStaticDescription(): String {
-        return "The declared access transformer is never used"
+        return "Reports unused Access Transformer entries"
+    }
+
+    override fun isSuppressedFor(element: PsiElement): Boolean {
+        return super.isSuppressedFor(element)
     }
 
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
@@ -47,33 +57,102 @@ class AtUsageInspection : LocalInspectionTool() {
                     return
                 }
 
-                val module = ModuleUtilCore.findModuleForPsiElement(element) ?: return
-                val instance = MinecraftFacet.getInstance(module) ?: return
-                val mcpModule = instance.getModuleOfType(McpModuleType) ?: return
-                val srgMap = mcpModule.mappingsManager?.mappingsNow ?: return
-
-                val member = element.function ?: element.fieldName ?: return
-                val reference = AtMemberReference.get(element, member) ?: return
-
-                val psi = when (member) {
-                    is AtFunction ->
-                        reference.resolveMember(element.project) ?: srgMap.tryGetMappedMethod(reference)?.resolveMember(
-                            element.project,
-                        ) ?: return
-                    is AtFieldName ->
-                        reference.resolveMember(element.project)
-                            ?: srgMap.tryGetMappedField(reference)?.resolveMember(element.project) ?: return
-                    else ->
+                val function = element.function
+                if (function != null) {
+                    checkElement(element, function)
+                    return
+                }
+
+                val fieldName = element.fieldName
+                if (fieldName != null) {
+                    checkElement(element, fieldName)
+                    return
+                }
+
+                // Only check class names if it is the target of the entry
+                checkElement(element, element.className)
+            }
+
+            private fun checkElement(entry: AtEntry, element: PsiElement) {
+                val referenced = element.reference?.resolve() ?: return
+                val scope = GlobalSearchScope.projectScope(element.project)
+                    .excludeFileTypes(element.project, AtFileType)
+                val query = ReferencesSearch.search(referenced, scope, true)
+                if (query.any()) {
+                    return
+                }
+
+                if (referenced is PsiMethod) {
+                    // The regular references search doesn't cover overridden methods
+                    val overridingQuery = OverridingMethodsSearch.search(referenced, scope, true)
+                    if (overridingQuery.any()) {
                         return
+                    }
+
+                    // Also ignore if other entries cover super methods
+                    val superMethods = referenced.findSuperMethods()
+                    for (childEntry in entry.containingFile.children) {
+                        if (childEntry !is AtEntry || childEntry == entry) {
+                            continue
+                        }
+
+                        val function = childEntry.function ?: continue
+                        val otherResolved = function.reference?.resolve()
+                        if (superMethods.contains(otherResolved)) {
+                            return
+                        }
+                    }
+                }
+
+                if (referenced is PsiClass) {
+                    // Do not report classes whose members are used in the mod
+                    for (field in referenced.fields) {
+                        if (ReferencesSearch.search(field, scope, true).any()) {
+                            return
+                        }
+                    }
+                    for (method in referenced.methods) {
+                        if (ReferencesSearch.search(method, scope, true).any()) {
+                            return
+                        }
+                    }
+                    for (innerClass in referenced.innerClasses) {
+                        if (ReferencesSearch.search(innerClass, scope, true).any()) {
+                            return
+                        }
+                    }
                 }
 
-                val query = ReferencesSearch.search(psi, GlobalSearchScope.projectScope(element.project))
-                query.findFirst()
-                    ?: holder.registerProblem(
-                        element,
-                        "Access Transformer entry is never used",
-                        ProblemHighlightType.LIKE_UNUSED_SYMBOL,
-                    )
+                val fix = RemoveAtEntryFix.forWholeLine(entry)
+                holder.registerProblem(entry, "Access Transformer entry is never used", fix)
+            }
+        }
+    }
+
+    private class RemoveAtEntryFix(startElement: PsiElement, endElement: PsiElement) :
+        LocalQuickFixOnPsiElement(startElement, endElement) {
+
+        override fun getFamilyName(): @IntentionFamilyName String = "Remove entry"
+
+        override fun getText(): @IntentionName String = familyName
+
+        override fun invoke(
+            project: Project,
+            file: PsiFile,
+            startElement: PsiElement,
+            endElement: PsiElement
+        ) {
+            startElement.parent.deleteChildRange(startElement, endElement)
+        }
+
+        companion object {
+
+            fun forWholeLine(entry: AtEntry): RemoveAtEntryFix {
+                val start = entry.siblings(forward = false, withSelf = false)
+                    .firstOrNull { it.elementType == AtTypes.CRLF }?.nextSibling
+                val end = entry.siblings(forward = true, withSelf = true)
+                    .firstOrNull { it.elementType == AtTypes.CRLF }
+                return RemoveAtEntryFix(start ?: entry, end ?: entry)
             }
         }
     }

src/main/kotlin/platform/mcp/at/psi/mixins/impl/AtClassNameImplMixin.kt

@@ -41,7 +41,7 @@ abstract class AtClassNameImplMixin(node: ASTNode) : ASTWrapperPsiElement(node),
     }
 
     override fun getReference(): PsiReference? {
-        return references.firstOrNull()
+        return references.lastOrNull()
     }
 
     override fun getReferences(): Array<out PsiReference?> {

src/main/kotlin/util/scope-utils.kt

@@ -0,0 +1,33 @@
+/*
+ * 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.util
+
+import com.intellij.openapi.fileTypes.FileType
+import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
+
+fun GlobalSearchScope.excludeFileTypes(project: Project, vararg fileTypes: FileType): GlobalSearchScope =
+    this.intersectWith(GlobalSearchScope.everythingScope(project).restrictByFileTypes(*fileTypes).not())
+
+fun GlobalSearchScope.restrictByFileTypes(vararg fileTypes: FileType): GlobalSearchScope =
+    GlobalSearchScope.getScopeRestrictedByFileTypes(this, *fileTypes)
+
+fun GlobalSearchScope.not(): GlobalSearchScope = GlobalSearchScope.notScope(this)

src/main/resources/META-INF/plugin.xml

@@ -996,6 +996,7 @@
                          language="Access Transformers"
                          enabledByDefault="true"
                          level="WARNING"
+                         editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                          hasStaticDescription="true"
                          implementationClass="com.demonwav.mcdev.platform.mcp.at.AtUsageInspection"/>
         <localInspection displayName="Invalid empty ItemStack comparison with ItemStack.EMPTY"

src/test/kotlin/platform/mcp/at/AtUsageInspectionTest.kt

@@ -0,0 +1,92 @@
+/*
+ * 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.mcp.at
+
+import com.demonwav.mcdev.facet.MinecraftFacet
+import com.demonwav.mcdev.framework.BaseMinecraftTest
+import com.demonwav.mcdev.platform.PlatformType
+import com.demonwav.mcdev.platform.mcp.McpModuleSettings
+import com.demonwav.mcdev.platform.mcp.McpModuleType
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+@DisplayName("Access Transformer Usage Inspection Tests")
+class AtUsageInspectionTest : BaseMinecraftTest(PlatformType.MCP, PlatformType.NEOFORGE) {
+
+    @Test
+    @DisplayName("Usage Inspection")
+    fun usageInspection() {
+        buildProject {
+            java(
+                "net/minecraft/Used.java",
+                """
+                package net.minecraft;
+                public class Used {
+                    public int usedField;
+                    public int unusedField;
+                    public void usedMethod() {}
+                    public void unusedMethod() {}
+                }
+                """.trimIndent(),
+                allowAst = true
+            )
+            java(
+                "net/minecraft/server/Unused.java",
+                """
+                package net.minecraft.server;
+                public class Unused {}
+                """.trimIndent(),
+                allowAst = true
+            )
+            java(
+                "com/demonwav/mcdev/mcp/test/TestMod.java",
+                """
+                package com.demonwav.mcdev.mcp.test;
+                public class TestMod {
+                    public TestMod () {
+                        net.minecraft.Used mc = new net.minecraft.Used();
+                        int value = mc.usedField;
+                        mc.usedMethod();
+                    }
+                }
+                """.trimIndent(),
+                allowAst = true
+            )
+            at(
+                "test_at.cfg",
+                """
+                public net.minecraft.Used
+                public net.minecraft.Used usedField
+                <warning descr="Access Transformer entry is never used">public net.minecraft.Used unusedField</warning>
+                public net.minecraft.Used usedMethod()V
+                <warning descr="Access Transformer entry is never used">public net.minecraft.Used unusedMethod()V</warning>
+                <warning descr="Access Transformer entry is never used">public net.minecraft.server.Unused</warning>
+                """.trimIndent())
+        }
+
+        // Force 1.20.2 because we test the non-SRG member names with NeoForge
+        MinecraftFacet.getInstance(fixture.module, McpModuleType)!!
+            .updateSettings(McpModuleSettings.State(minecraftVersion = "1.20.2"))
+
+        fixture.enableInspections(AtUsageInspection::class.java)
+        fixture.checkHighlighting()
+    }
+}