AT Overhaul

changelog.md

@@ -6,6 +6,18 @@
 
 - `plugin.yml`, `paper-plugin.yml` and `bungee.yml` main class reference and validity inspection
 
+### Changed
+
+- Overhauled Access Transformer support:
+  - many lexing errors should now be fixed
+  - class names and member names now have their own references, replacing the custom Goto handler
+  - SRG names are no longer used on NeoForge 1.20.2+ and a new copy action is available for it
+  - the usage inspection no longer incorrectly reports methods overridden in your code or entries covering super methods
+  - suppressing inspections is now possible by adding `# Suppress:AtInspectionName` after an entry or at the start of the file, or using the built-in suppress action
+  - added an inspection to report unresolved references, to help find out old, superfluous entries
+  - added an inspection to report duplicate entries in the same file
+  - added formatting support, class and member names are configured to align by default
+
 ## [1.8.1] - 2024-08-10
 
 ### Added

src/main/grammars/AtLexer.flex

@@ -48,16 +48,20 @@ import static com.intellij.psi.TokenType.*;
 PRIMITIVE=[ZBCSIFDJV]
 CLASS_VALUE=(\[+[ZBCSIFDJ]|(\[*L[^;\n]+;))
 KEYWORD_ELEMENT=(public|private|protected|default)([-+]f)?
-NAME_ELEMENT=([\p{L}_\p{Sc}][\p{L}\p{N}_\p{Sc}]*)|<init>
-CLASS_NAME_ELEMENT=([\p{L}_\p{Sc}][\p{L}\p{N}_\p{Sc}]*\.)*[\p{L}_\p{Sc}][\p{L}\p{N}_\p{Sc}]*
+IDENTIFIER=[\p{L}_\p{Sc}][\p{L}\p{N}_\p{Sc}]*
+NAME_ELEMENT=({IDENTIFIER})|<init>
+CLASS_NAME_ELEMENT=({IDENTIFIER}*\.)*{IDENTIFIER}
 COMMENT=#.*
 CRLF=\n|\r|\r\n
 WHITE_SPACE=\s
 
 %%
 
 <YYINITIAL> {
-    {KEYWORD_ELEMENT}                           { yybegin(CLASS_NAME); return KEYWORD_ELEMENT; }
+    // Force a whitespace because otherwise the keyword and class name can be right next to each other
+    {KEYWORD_ELEMENT}/{WHITE_SPACE}             { yybegin(CLASS_NAME); return KEYWORD_ELEMENT; }
+    // Fallback to avoid breaking code highlighting at the keyword
+    {NAME_ELEMENT}                              { return NAME_ELEMENT; }
 }
 
 <CLASS_NAME> {
@@ -73,7 +77,7 @@ WHITE_SPACE=\s
     "("                                         { return OPEN_PAREN; }
     ")"                                         { return CLOSE_PAREN; }
     {CLASS_VALUE}                               { return CLASS_VALUE; }
-    {PRIMITIVE} ({PRIMITIVE}|{CLASS_VALUE})*    { zzMarkedPos = zzStartRead + 1; return PRIMITIVE; }
+    {PRIMITIVE}                                 { return PRIMITIVE; }
 }
 
 {CRLF}                                          { yybegin(YYINITIAL); return CRLF; }

src/main/grammars/AtParser.bnf

@@ -32,7 +32,7 @@
     elementTypeClass="com.demonwav.mcdev.platform.mcp.at.psi.AtElementType"
     tokenTypeClass="com.demonwav.mcdev.platform.mcp.at.psi.AtTokenType"
 
-    consumeTokenMethod="consumeTokenFast"
+    consumeTokenMethod(".*_recover")="consumeTokenFast"
 }
 
 at_file ::= line*
@@ -60,7 +60,9 @@ keyword ::= KEYWORD_ELEMENT {
     methods=[
         keywordElement="KEYWORD_ELEMENT"
     ]
+    recoverWhile=keyword_recover
 }
+private keyword_recover ::= !(NAME_ELEMENT | CLASS_NAME_ELEMENT)
 
 class_name ::= CLASS_NAME_ELEMENT {
     mixin="com.demonwav.mcdev.platform.mcp.at.psi.mixins.impl.AtClassNameImplMixin"

src/main/kotlin/platform/mcp/actions/CopyNeoForgeAtAction.kt

@@ -0,0 +1,98 @@
+/*
+ * 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.actions
+
+import com.demonwav.mcdev.platform.mcp.actions.SrgActionBase.Companion.showBalloon
+import com.demonwav.mcdev.platform.mcp.actions.SrgActionBase.Companion.showSuccessBalloon
+import com.demonwav.mcdev.platform.mcp.at.usesSrgMemberNames
+import com.demonwav.mcdev.platform.mixin.handlers.ShadowHandler
+import com.demonwav.mcdev.util.descriptor
+import com.demonwav.mcdev.util.getDataFromActionEvent
+import com.intellij.openapi.actionSystem.ActionUpdateThread
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.editor.Editor
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiField
+import com.intellij.psi.PsiMember
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.PsiReference
+import java.awt.Toolkit
+import java.awt.datatransfer.StringSelection
+
+class CopyNeoForgeAtAction : AnAction() {
+
+    override fun getActionUpdateThread(): ActionUpdateThread = ActionUpdateThread.BGT
+
+    override fun update(e: AnActionEvent) {
+        e.presentation.isEnabledAndVisible = isAvailable(e)
+    }
+
+    private fun isAvailable(e: AnActionEvent): Boolean {
+        val data = getDataFromActionEvent(e) ?: return false
+        return data.instance.usesSrgMemberNames() == false
+    }
+
+    override fun actionPerformed(e: AnActionEvent) {
+        val data = getDataFromActionEvent(e) ?: return
+
+        var parent = data.element.parent
+        if (parent is PsiMember) {
+            val shadowTarget = ShadowHandler.getInstance()?.findFirstShadowTargetForReference(parent)?.element
+            if (shadowTarget != null) {
+                parent = shadowTarget
+            }
+        }
+
+        if (parent is PsiReference) {
+            parent = parent.resolve() ?: return showBalloon("Not a valid element", e)
+        }
+
+        when (parent) {
+            is PsiClass -> {
+                val fqn = parent.qualifiedName ?: return showBalloon("Could not find class FQN", e)
+                copyToClipboard(data.editor, data.element, fqn)
+            }
+            is PsiField -> {
+                val classFqn = parent.containingClass?.qualifiedName
+                    ?: return showBalloon("Could not find class FQN", e)
+                copyToClipboard(data.editor, data.element, "$classFqn ${parent.name}")
+            }
+            is PsiMethod -> {
+                val classFqn = parent.containingClass?.qualifiedName
+                    ?: return showBalloon("Could not find class FQN", e)
+                val methodDescriptor = parent.descriptor
+                    ?: return showBalloon("Could not compute method descriptor", e)
+                copyToClipboard(data.editor, data.element, "$classFqn ${parent.name}$methodDescriptor")
+            }
+            else -> showBalloon("Not a valid element", e)
+        }
+        return
+    }
+
+    private fun copyToClipboard(editor: Editor, element: PsiElement, text: String) {
+        val stringSelection = StringSelection(text)
+        val clpbrd = Toolkit.getDefaultToolkit().systemClipboard
+        clpbrd.setContents(stringSelection, null)
+        showSuccessBalloon(editor, element, "Copied $text")
+    }
+}

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

@@ -23,17 +23,51 @@ package com.demonwav.mcdev.platform.mcp.at
 import com.demonwav.mcdev.asset.PlatformAssets
 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.intellij.extapi.psi.PsiFileBase
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.module.ModuleUtilCore
 import com.intellij.psi.FileViewProvider
+import com.intellij.psi.PsiComment
+import com.intellij.psi.PsiElement
 
 class AtFile(viewProvider: FileViewProvider) : PsiFileBase(viewProvider, AtLanguage) {
 
     init {
         setup()
     }
 
+    val headComments: List<PsiComment>
+        get() {
+            val comments = mutableListOf<PsiComment>()
+            for (child in children) {
+                if (child is AtEntry) {
+                    break
+                }
+
+                if (child is PsiComment) {
+                    comments.add(child)
+                }
+            }
+
+            return comments
+        }
+
+    fun addHeadComment(text: String) {
+        val toAdd = text.lines().flatMap { listOf(AtElementFactory.createComment(project, it)) }
+        val lastHeadComment = headComments.lastOrNull()
+        if (lastHeadComment == null) {
+            for (comment in toAdd.reversed()) {
+                addAfter(comment, null)
+            }
+        } else {
+            var previousComment: PsiElement? = lastHeadComment
+            for (comment in toAdd) {
+                previousComment = addAfter(comment, previousComment)
+            }
+        }
+    }
+
     private fun setup() {
         if (ApplicationManager.getApplication().isUnitTestMode) {
             return

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

@@ -43,22 +43,22 @@ class AtParserDefinition : ParserDefinition {
     override fun createElement(node: ASTNode): PsiElement = AtTypes.Factory.createElement(node)
 
     override fun spaceExistenceTypeBetweenTokens(left: ASTNode, right: ASTNode) =
-        map.entries.firstOrNull { e -> left.elementType == e.key.first || right.elementType == e.key.second }?.value
-            ?: ParserDefinition.SpaceRequirements.MUST_NOT
+        map[left.elementType to right.elementType] ?: ParserDefinition.SpaceRequirements.MUST_NOT
 
     companion object {
         private val COMMENTS = TokenSet.create(AtTypes.COMMENT)
 
         private val FILE = IFileElementType(Language.findInstance(AtLanguage::class.java))
 
         private val map: Map<Pair<IElementType, IElementType>, ParserDefinition.SpaceRequirements> = mapOf(
-            (AtTypes.KEYWORD to AtTypes.CLASS_NAME) to ParserDefinition.SpaceRequirements.MUST,
-            (AtTypes.CLASS_NAME to AtTypes.FIELD_NAME) to ParserDefinition.SpaceRequirements.MUST,
-            (AtTypes.CLASS_NAME to AtTypes.FUNCTION) to ParserDefinition.SpaceRequirements.MUST,
-            (AtTypes.CLASS_NAME to AtTypes.ASTERISK) to ParserDefinition.SpaceRequirements.MUST,
+            (AtTypes.KEYWORD_ELEMENT to AtTypes.CLASS_NAME_ELEMENT) to ParserDefinition.SpaceRequirements.MUST,
+            (AtTypes.CLASS_NAME_ELEMENT to AtTypes.FIELD_NAME) to ParserDefinition.SpaceRequirements.MUST,
+            (AtTypes.CLASS_NAME_ELEMENT to AtTypes.FUNCTION) to ParserDefinition.SpaceRequirements.MUST,
+            (AtTypes.CLASS_NAME_ELEMENT to AtTypes.ASTERISK_ELEMENT) to ParserDefinition.SpaceRequirements.MUST,
+            (AtTypes.CLASS_NAME_ELEMENT to AtTypes.COMMENT) to ParserDefinition.SpaceRequirements.MUST,
             (AtTypes.FIELD_NAME to AtTypes.COMMENT) to ParserDefinition.SpaceRequirements.MUST,
-            (AtTypes.ASTERISK to AtTypes.COMMENT) to ParserDefinition.SpaceRequirements.MUST,
-            (AtTypes.COMMENT to AtTypes.KEYWORD) to ParserDefinition.SpaceRequirements.MUST_LINE_BREAK,
+            (AtTypes.ASTERISK_ELEMENT to AtTypes.COMMENT) to ParserDefinition.SpaceRequirements.MUST,
+            (AtTypes.COMMENT to AtTypes.KEYWORD_ELEMENT) to ParserDefinition.SpaceRequirements.MUST_LINE_BREAK,
             (AtTypes.COMMENT to AtTypes.COMMENT) to ParserDefinition.SpaceRequirements.MUST_LINE_BREAK,
             (AtTypes.FUNCTION to AtTypes.COMMENT) to ParserDefinition.SpaceRequirements.MUST,
         )