}

    /**
     * Checks if the reference is an implicit reference to a companion object via the containing class.
     *
     * Example:
     * ```
     * class A {
     *    companion object {
     *       fun foo() {}
     *    }
     * }
     * ```
     *
     * For the case provided, inside the call `A.foo()`,

import org.jetbrains.kotlin.idea.references.KtReference
import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
import org.jetbrains.kotlin.resolve.BindingContext

internal class KaFe10ReferenceResolveProvider(
    override val analysisSession: KaFe10Session,
) : KaReferenceResolveProvider(), KaFe10SessionComponent {
    override fun isImplicitReferenceToCompanion(reference: KtReference): Boolean {

        val position = testServices.expressionMarkerProvider.getCaretPosition(mainFile)
        val reference = mainFile.findReferenceAt(position)
        assertNotNull(reference)
        val expectedAlias = mainModule.testModule.directives.singleValue(Directives.TYPE_ALIAS)
        val importDirective = mainFile.importDirectives.find { it.aliasName == expectedAlias }

        mainModule: KtTestModule,
        testServices: TestServices,
    ): String {
        val reference = context.element ?: return "no references found"

        return analyzeReferenceElement(reference.element, mainModule) {
            val symbols = reference.resolveToSymbols()
            val symbolsAgain = reference.resolveToSymbols()
            testServices.assertions.assertEquals(symbols, symbolsAgain)

        val isImplicitCompanionReference = executeOnPooledThreadInReadAction {
            analyseForTest(referenceExpression) {
                val reference = referenceExpression.reference as KtReference
                reference.isImplicitReferenceToCompanion()
            }
        }

        val actual = buildString {
            append("isImplicitCompanionReference: $isImplicitCompanionReference")

    override fun resolve(ref: KtReference, incompleteCode: Boolean): Array<ResolveResult> {
        check(ref is KaFirReference) { "reference should be FirKtReference, but was ${ref::class}" }
        check(ref is AbstractKtReference<*>) { "reference should be AbstractKtReference, but was ${ref::class}" }
        return allowAnalysisOnEdt {
            allowAnalysisFromWriteAction {

import org.jetbrains.kotlin.idea.references.KtReference
import org.jetbrains.kotlin.idea.references.KtSimpleNameReference

internal class KaFirReferenceResolveProvider(
    override val analysisSession: KaFirSession,
) : KaReferenceResolveProvider(), KaFirSessionComponent {
    override fun isImplicitReferenceToCompanion(reference: KtReference): Boolean {
        if (reference !is KtSimpleNameReference) {
            return false

        carets.flatMap { findReferencesAtCaret(mainFile, it.offset) }.forEach { reference ->
            val resolved = reference.resolve() ?: testServices.assertions.fail { "Could not resolve reference at caret" }
            testServices.assertions.assertTrue(reference.isReferenceTo(resolved))
            testServices.assertions.assertEqualsToTestDataFileSibling(resolved.renderResolvedPsi(testServices))

    public void setSession(MavenSession session) {
        AtomicReference<MavenSession> reference = DefaultLegacySupport.SESSION.get();
        if (reference != null) {
            reference.set(null);
        }

        if (session == null && reference != null) {
            DefaultLegacySupport.SESSION.remove();
        } else {

 */

package org.jetbrains.kotlin.analysis.api.components

import org.jetbrains.kotlin.idea.references.KtReference

public abstract class KaReferenceResolveProvider {
    public abstract fun isImplicitReferenceToCompanion(reference: KtReference): Boolean
}