ERROR:
The file src/main/kotlin/platform/mcp/ct/CtCompletionContributor.kt could not be found in 3f914457e1a535024dc2eb9fb0d94ae75141755c (/data/teamcity_server/datadir/system/caches/git/git-89549425.git, https://[email protected]/minecraft-dev/MinecraftDev#refs/heads/dev)

      

        
/*
 * Minecraft Development for IntelliJ
 *
 * https://mcdev.io/
 *
 * Copyright (C) 2025 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.ct
 
import com.demonwav.mcdev.platform.mcp.ct.gen.psi.CtTypes
import com.intellij.codeInsight.completion.CodeCompletionHandlerBase
import com.intellij.codeInsight.completion.CompletionContributor
import com.intellij.codeInsight.completion.CompletionParameters
import com.intellij.codeInsight.completion.CompletionProvider
import com.intellij.codeInsight.completion.CompletionResultSet
import com.intellij.codeInsight.completion.CompletionType
import com.intellij.codeInsight.completion.InsertionContext
import com.intellij.codeInsight.lookup.LookupElementBuilder
import com.intellij.openapi.application.runReadAction
import com.intellij.patterns.PlatformPatterns
import com.intellij.psi.PsiDocumentManager
import com.intellij.psi.TokenType
import com.intellij.psi.util.elementType
import com.intellij.psi.util.prevLeaf
import com.intellij.util.ProcessingContext
 
class CtCompletionContributor : CompletionContributor() {
    init {
        extend(null, PlatformPatterns.psiElement(), CtHeaderCompletionProvider)
        val whitespace = PlatformPatterns.psiElement(TokenType.WHITE_SPACE)
        val namespacePattern = PlatformPatterns.psiElement()
            .afterLeafSkipping(whitespace, PlatformPatterns.psiElement(CtTypes.HEADER_VERSION_ELEMENT))
        extend(null, namespacePattern, CtNamespaceCompletionProvider)
        val entryStartPattern = PlatformPatterns.psiElement().afterLeaf(PlatformPatterns.psiElement(CtTypes.CRLF))
        extend(null, entryStartPattern, CtEntryStartCompletionProvider)
        val awTargetPattern = PlatformPatterns.psiElement()
            .afterLeafSkipping(whitespace, PlatformPatterns.psiElement(CtTypes.ACCESS_ELEMENT))
        extend(null, awTargetPattern, CtAwTargetCompletionProvider)
    }
}
 
private fun insertWhitespace(context: InsertionContext) {
    PsiDocumentManager.getInstance(context.project)
        .doPostponedOperationsAndUnblockDocument(context.document)
    context.document.insertString(context.editor.caretModel.offset, " ")
    context.editor.caretModel.moveCaretRelatively(1, 0, false, false, false)
    context.setLaterRunnable {
        runReadAction {
            CodeCompletionHandlerBase.createHandler(CompletionType.BASIC)
                .invokeCompletion(context.project, context.editor)
        }
    }
}
 
object CtHeaderCompletionProvider : CompletionProvider<CompletionParameters>() {
 
    override fun addCompletions(
        parameters: CompletionParameters,
        context: ProcessingContext,
        result: CompletionResultSet,
    ) {
        if (parameters.position.prevLeaf(true) == null) {
            result.addElement(LookupElementBuilder.create("accessWidener v1 named"))
            result.addElement(LookupElementBuilder.create("accessWidener v2 named"))
            result.addElement(LookupElementBuilder.create("classTweaker v1 named"))
        }
    }
}
 
object CtNamespaceCompletionProvider : CompletionProvider<CompletionParameters>() {
 
    override fun addCompletions(
        parameters: CompletionParameters,
        context: ProcessingContext,
        result: CompletionResultSet,
    ) = result.addAllElements(listOf("named", "intermediary").map(LookupElementBuilder::create))
}
 
object CtEntryStartCompletionProvider : CompletionProvider<CompletionParameters>() {
 
    override fun addCompletions(
        parameters: CompletionParameters,
        context: ProcessingContext,
        result: CompletionResultSet,
    ) {
        val elements = listOf(
            "accessible",
            "transitive-accessible",
            "extendable",
            "transitive-extendable",
            "mutable",
            "transitive-mutable",
            "inject-interface",
            "transitive-inject-interface"
        ).map { LookupElementBuilder.create(it).withInsertHandler { ctx, _ -> insertWhitespace(ctx) } }
        result.addAllElements(elements)
    }
}
 
object CtAwTargetCompletionProvider : CompletionProvider<CompletionParameters>() {
 
    override fun addCompletions(
        parameters: CompletionParameters,
        context: ProcessingContext,
        result: CompletionResultSet,
    ) {
        val text = parameters.position
            .prevLeaf { it.elementType == CtTypes.ACCESS_ELEMENT || it.elementType == CtTypes.CRLF }?.text ?: return
        val elements = CtAnnotator.compatibleByAccessMap.get(text)
            .map { LookupElementBuilder.create(it).withInsertHandler { ctx, _ -> insertWhitespace(ctx) } }
        result.addAllElements(elements)
    }
}