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

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 {

    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 {

        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)

        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))

    }

    /**
     * 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()`,

        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 }

        val referenceExpression = testServices.expressionMarkerProvider.getElementOfTypeAtCaret<KtReferenceExpression>(ktFile)
        val symbolByReference = referenceExpression.mainReference.resolveToSymbol() ?: error("Failed to resolve reference")

        val symbolByJavaPsi = when (val javaPsi = symbolByReference.psi) {
            is PsiClass -> javaPsi.getNamedClassSymbol()
            is PsiMember -> javaPsi.getCallableSymbol()

~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

 -----
 Lifecycles Reference
 -----
 Hervé Boutemy
 -----
 2013-08-02
 -----

Lifecycles Reference

  Maven defines 4 lifecycles in {{{./apidocs/org/apache/maven/lifecycle/providers/package-summary.html}<<<org.apache.maven.lifecycle.providers>>>}} package:

%{toc|fromDepth=2}

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

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