Support suppressing AT inspections for the whole file

Also fixes AtParserDefinition#spaceExistenceTypeBetweenTokens

Author: RedNesto

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/AtInspectionSuppressor.kt

@@ -29,14 +29,26 @@ import com.intellij.codeInspection.util.IntentionName
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
+import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.util.parentOfType
 
 class AtInspectionSuppressor : InspectionSuppressor {
 
     override fun isSuppressedFor(element: PsiElement, toolId: String): Boolean {
         val entry = element.parentOfType<AtEntry>(withSelf = true) ?: return false
-        val comment = entry.commentText ?: return false
-        val suppressed = comment.substringAfter("Suppress:").substringBefore(' ').split(',')
+        val entryComment = entry.commentText
+        if (entryComment != null) {
+            if (isSuppressing(entryComment, toolId)) {
+                return true
+            }
+        }
+
+        val file = element.containingFile as AtFile
+        return file.headComments.any { comment -> isSuppressing(comment.text, toolId) }
+    }
+
+    private fun isSuppressing(entryComment: String, toolId: String): Boolean {
+        val suppressed = entryComment.substringAfter("Suppress:").substringBefore(' ').split(',')
         return toolId in suppressed
     }
 
@@ -48,12 +60,24 @@ class AtInspectionSuppressor : InspectionSuppressor {
             return SuppressQuickFix.EMPTY_ARRAY
         }
 
-        return arrayOf(AtSuppressQuickFix(element, toolId))
+        val entry = element as? AtEntry
+            ?: element.parentOfType<AtEntry>(withSelf = true)
+            ?: PsiTreeUtil.getPrevSiblingOfType(element, AtEntry::class.java) // For when we are at a CRLF
+        return if (entry != null) {
+            arrayOf(AtSuppressQuickFix(entry, toolId), AtSuppressQuickFix(element.containingFile, toolId))
+        } else {
+            arrayOf(AtSuppressQuickFix(element.containingFile, toolId))
+        }
     }
 
-    class AtSuppressQuickFix(element: PsiElement, val toolId: String) : LocalQuickFixOnPsiElement(element), SuppressQuickFix {
+    class AtSuppressQuickFix(element: PsiElement, val toolId: String) :
+        LocalQuickFixOnPsiElement(element), SuppressQuickFix {
 
-        override fun getText(): @IntentionName String = "Suppress $toolId"
+        override fun getText(): @IntentionName String = when (startElement) {
+            is AtEntry -> "Suppress $toolId for entry"
+            is AtFile -> "Suppress $toolId for file"
+            else -> "Suppress $toolId"
+        }
 
         override fun getFamilyName(): @IntentionFamilyName String = "Suppress inspection"
 
@@ -63,7 +87,13 @@ class AtInspectionSuppressor : InspectionSuppressor {
             startElement: PsiElement,
             endElement: PsiElement
         ) {
-            val entry = startElement.parentOfType<AtEntry>(withSelf = true) ?: return
+            when (startElement) {
+                is AtEntry -> suppressForEntry(startElement)
+                is AtFile -> suppressForFile(startElement)
+            }
+        }
+
+        private fun suppressForEntry(entry: AtEntry) {
             val commentText = entry.commentText?.trim()
             if (commentText == null) {
                 entry.setComment("Suppress:$toolId")
@@ -77,10 +107,32 @@ class AtInspectionSuppressor : InspectionSuppressor {
             }
 
             val suppressEnd = commentText.indexOf(' ', suppressStart).takeUnless { it == -1 } ?: commentText.length
-            val newComment = commentText.substring(suppressStart, suppressEnd) + ",$toolId" + commentText.substring(suppressEnd)
+            val newComment =
+                commentText.substring(suppressStart, suppressEnd) + ",$toolId" + commentText.substring(suppressEnd)
             entry.setComment(newComment)
         }
 
+        private fun suppressForFile(file: AtFile) {
+            val existingSuppressComment = file.headComments.firstOrNull { it.text.contains("Suppress:") }
+            if (existingSuppressComment == null) {
+                file.addHeadComment("Suppress:$toolId")
+                return
+            }
+
+            val commentText = existingSuppressComment.text
+            val suppressStart = commentText.indexOf("Suppress:")
+            if (suppressStart == -1) {
+                file.addHeadComment("Suppress:$toolId")
+                return
+            }
+
+            val suppressEnd = commentText.indexOf(' ', suppressStart).takeUnless { it == -1 } ?: commentText.length
+            val newCommentText =
+                commentText.substring(suppressStart, suppressEnd) + ",$toolId" + commentText.substring(suppressEnd)
+            val newComment = AtElementFactory.createComment(file.project, newCommentText)
+            existingSuppressComment.replace(newComment)
+        }
+
         override fun isAvailable(
             project: Project,
             context: PsiElement

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

@@ -45,8 +45,7 @@ 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 WHITE_SPACES = TokenSet.create(TokenType.WHITE_SPACE)
@@ -55,13 +54,14 @@ class AtParserDefinition : ParserDefinition {
         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,
         )

src/test/kotlin/framework/test-util.kt

@@ -24,6 +24,7 @@ package com.demonwav.mcdev.framework
 
 import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.lexer.Lexer
+import com.intellij.openapi.fileTypes.FileType
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.OrderRootType
 import com.intellij.openapi.roots.libraries.Library
@@ -130,6 +131,19 @@ fun testInspectionFix(fixture: JavaCodeInsightTestFixture, basePath: String, fix
     fixture.checkResult(expected)
 }
 
+fun testInspectionFix(
+    fixture: JavaCodeInsightTestFixture,
+    fixName: String,
+    fileType: FileType,
+    before: String,
+    after: String
+) {
+    fixture.configureByText(fileType, before)
+    val intention = fixture.findSingleIntention(fixName)
+    fixture.launchAction(intention)
+    fixture.checkResult(after)
+}
+
 fun <T> assertEqualsUnordered(expected: Collection<T>, actual: Collection<T>) {
     val expectedSet = expected.toSet()
     val actualSet = actual.toSet()

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

@@ -24,7 +24,7 @@ import com.demonwav.mcdev.framework.BaseMinecraftTest
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 
-@DisplayName("Access Transformer Duplicate Entry Inspection")
+@DisplayName("Access Transformer Duplicate Entry Inspection Tests")
 class AtDuplicateEntryInspectionTest : BaseMinecraftTest() {
 
     @Test

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

@@ -0,0 +1,131 @@
+/*
+ * 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.framework.BaseMinecraftTest
+import com.demonwav.mcdev.framework.testInspectionFix
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+@DisplayName("Access Transformer Inspection Suppressor Tests")
+class AtInspectionSuppressorTest : BaseMinecraftTest() {
+
+    @Test
+    @DisplayName("Entry-Level Suppress")
+    fun entryLevelSuppress() {
+        fixture.configureByText(
+            "test_at.cfg",
+            """
+            public Unresolved # Suppress:AtUnresolvedReference
+            public <error descr="Cannot resolve symbol 'Unresolved'">Unresolved</error>
+            """.trimIndent()
+        )
+
+        fixture.enableInspections(AtUnresolvedReferenceInspection::class.java)
+        fixture.checkHighlighting()
+    }
+
+    @Test
+    @DisplayName("Entry-Level Suppress Fix")
+    fun entryLevelSuppressFix() {
+        fixture.enableInspections(AtUnresolvedReferenceInspection::class.java)
+        testInspectionFix(
+            fixture,
+            "Suppress AtUnresolvedReference for entry",
+            AtFileType,
+            "public <caret>Unresolved",
+            "public Unresolved # Suppress:AtUnresolvedReference"
+        )
+    }
+
+    @Test
+    @DisplayName("File-Level Suppress")
+    fun fileLevelSuppress() {
+        fixture.configureByText(
+            "test_at.cfg",
+            """
+            # Suppress:AtUnresolvedReference
+            public Unresolved
+            public Unresolved
+            """.trimIndent()
+        )
+
+        fixture.enableInspections(AtUnresolvedReferenceInspection::class.java)
+        fixture.checkHighlighting()
+    }
+
+    @Test
+    @DisplayName("File-Level Suppress Fix With No Existing Comments")
+    fun fileLevelSuppressFixNoComments() {
+        fixture.enableInspections(AtUnresolvedReferenceInspection::class.java)
+        testInspectionFix(
+            fixture,
+            "Suppress AtUnresolvedReference for file",
+            AtFileType,
+            "public <caret>Unresolved",
+            """
+            # Suppress:AtUnresolvedReference
+            public Unresolved
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    @DisplayName("File-Level Suppress Fix With Unrelated Comment")
+    fun fileLevelSuppressFixWithUnrelatedComment() {
+        fixture.enableInspections(AtUnresolvedReferenceInspection::class.java)
+        testInspectionFix(
+            fixture,
+            "Suppress AtUnresolvedReference for file",
+            AtFileType,
+            """
+            # This is a header comment
+            public <caret>Unresolved
+            """.trimIndent(),
+            """
+            # This is a header comment
+            # Suppress:AtUnresolvedReference
+            public Unresolved
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    @DisplayName("File-Level Suppress Fix With Existing Suppress")
+    fun fileLevelSuppressFixWithExistingSuppress() {
+        fixture.enableInspections(AtUnresolvedReferenceInspection::class.java)
+        testInspectionFix(
+            fixture,
+            "Suppress AtUnresolvedReference for file",
+            AtFileType,
+            """
+            # This is a header comment
+            # Suppress:AtUsage
+            public <caret>Unresolved
+            """.trimIndent(),
+            """
+            # This is a header comment
+            # Suppress:AtUsage,AtUnresolvedReference
+            public Unresolved
+            """.trimIndent()
+        )
+    }
+}