KtReferenceResolver: implement resolveToPsiElements() via FE IR (~60% supported)

generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt

@@ -55,7 +55,6 @@ import org.jetbrains.kotlin.idea.conversion.copy.AbstractLiteralKotlinToKotlinCo
 import org.jetbrains.kotlin.idea.conversion.copy.AbstractLiteralTextToKotlinCopyPasteTest
 import org.jetbrains.kotlin.idea.conversion.copy.AbstractTextJavaToKotlinCopyPasteConversionTest
 import org.jetbrains.kotlin.idea.coverage.AbstractKotlinCoverageOutputFilesTest
-import org.jetbrains.kotlin.idea.debugger.*
 import org.jetbrains.kotlin.idea.debugger.evaluate.*
 import org.jetbrains.kotlin.idea.debugger.test.sequence.exec.AbstractSequenceTraceTestCase
 import org.jetbrains.kotlin.idea.debugger.test.*
@@ -500,6 +499,10 @@ fun main(args: Array<String>) {
             model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
         }
 
+        testClass<AbstractFirReferenceResolveTest> {
+            model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
+        }
+
         testClass<AbstractReferenceResolveInJavaTest> {
             model("resolve/referenceInJava/binaryAndSource", extension = "java")
             model("resolve/referenceInJava/sourceOnly", extension = "java")

generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.183

@@ -502,6 +502,10 @@ fun main(args: Array<String>) {
             model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
         }
 
+        testClass<AbstractFirReferenceResolveTest> {
+            model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
+        }
+
         testClass<AbstractReferenceResolveInJavaTest> {
             model("resolve/referenceInJava/binaryAndSource", extension = "java")
             model("resolve/referenceInJava/sourceOnly", extension = "java")

generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as34

@@ -490,6 +490,10 @@ fun main(args: Array<String>) {
             model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
         }
 
+        testClass<AbstractFirReferenceResolveTest> {
+            model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
+        }
+
         testClass<AbstractReferenceResolveInJavaTest> {
             model("resolve/referenceInJava/binaryAndSource", extension = "java")
             model("resolve/referenceInJava/sourceOnly", extension = "java")

generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as35

@@ -490,6 +490,10 @@ fun main(args: Array<String>) {
             model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
         }
 
+        testClass<AbstractFirReferenceResolveTest> {
+            model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
+        }
+
         testClass<AbstractReferenceResolveInJavaTest> {
             model("resolve/referenceInJava/binaryAndSource", extension = "java")
             model("resolve/referenceInJava/sourceOnly", extension = "java")

generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as36

@@ -490,6 +490,10 @@ fun main(args: Array<String>) {
             model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
         }
 
+        testClass<AbstractFirReferenceResolveTest> {
+            model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME)
+        }
+
         testClass<AbstractReferenceResolveInJavaTest> {
             model("resolve/referenceInJava/binaryAndSource", extension = "java")
             model("resolve/referenceInJava/sourceOnly", extension = "java")

idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtReference.kt

@@ -21,11 +21,30 @@ import com.intellij.psi.impl.source.resolve.ResolveCache
 import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.psi
+import org.jetbrains.kotlin.fir.references.*
+import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.toSymbol
+import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
+import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
+import org.jetbrains.kotlin.idea.fir.FirResolution
+import org.jetbrains.kotlin.idea.fir.firResolveState
+import org.jetbrains.kotlin.idea.fir.getOrBuildFir
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
 import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtPackageDirective
 import org.jetbrains.kotlin.psi.KtReferenceExpression
+import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getReferenceTargets
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
@@ -74,15 +93,160 @@ abstract class AbstractKtReference<T : KtElement>(element: T) : PsiPolyVariantRe
     override fun toString() = this::class.java.simpleName + ": " + expression.text
 
     companion object {
+        private object FirReferenceResolveHelper {
+            fun FirResolvedTypeRef.toTargetPsi(session: FirSession): PsiElement? {
+                val type = type as? ConeLookupTagBasedType ?: return null
+                return (type.lookupTag.toSymbol(session) as? AbstractFirBasedSymbol<*>)?.fir?.psi
+            }
+
+            fun ClassId.toTargetPsi(session: FirSession, calleeReference: FirReference? = null): PsiElement? {
+                val classLikeDeclaration = ConeClassLikeLookupTagImpl(this).toSymbol(session)?.fir
+                if (classLikeDeclaration is FirRegularClass) {
+                    if (calleeReference is FirResolvedNamedReference) {
+                        val callee = calleeReference.resolvedSymbol.fir as? FirCallableMemberDeclaration
+                        // TODO: check callee owner directly?
+                        if (callee !is FirConstructor && callee?.isStatic != true) {
+                            classLikeDeclaration.companionObject?.let { return it.psi }
+                        }
+                    }
+                }
+                return classLikeDeclaration?.psi
+            }
+
+            fun FirReference.toTargetPsi(session: FirSession): PsiElement? {
+                return when (this) {
+                    is FirResolvedNamedReference -> {
+                        resolvedSymbol.fir.psi
+                    }
+                    is FirResolvedCallableReference -> {
+                        resolvedSymbol.fir.psi
+                    }
+                    is FirThisReference -> {
+                        boundSymbol?.fir?.psi
+                    }
+                    is FirSuperReference -> {
+                        (superTypeRef as? FirResolvedTypeRef)?.toTargetPsi(session)
+                    }
+                    else -> {
+                        null
+                    }
+                }
+            }
+
+            fun resolveToPsiElements(ref: AbstractKtReference<KtElement>): Collection<PsiElement> {
+                val expression = ref.expression
+                val state = expression.firResolveState()
+                val session = state.getSession(expression)
+                when (val fir = expression.getOrBuildFir(state)) {
+                    is FirResolvable -> {
+                        return listOfNotNull(fir.calleeReference.toTargetPsi(session))
+                    }
+                    is FirResolvedTypeRef -> {
+                        return listOfNotNull(fir.toTargetPsi(session))
+                    }
+                    is FirResolvedQualifier -> {
+                        val classId = fir.classId ?: return emptyList()
+                        // Distinguish A.foo() from A(.Companion).foo()
+                        // Make expression.parent as? KtDotQualifiedExpression local function
+                        var parent = expression.parent as? KtDotQualifiedExpression
+                        while (parent != null) {
+                            val selectorExpression = parent.selectorExpression ?: break
+                            if (selectorExpression === expression) {
+                                parent = parent.parent as? KtDotQualifiedExpression
+                                continue
+                            }
+                            val parentFir = selectorExpression.getOrBuildFir(state)
+                            if (parentFir is FirQualifiedAccess) {
+                                return listOfNotNull(classId.toTargetPsi(session, parentFir.calleeReference))
+                            }
+                            parent = parent.parent as? KtDotQualifiedExpression
+                        }
+                        return listOfNotNull(classId.toTargetPsi(session))
+                    }
+                    is FirAnnotationCall -> {
+                        val type = fir.typeRef as? FirResolvedTypeRef ?: return emptyList()
+                        return listOfNotNull(type.toTargetPsi(session))
+                    }
+                    is FirResolvedImport -> {
+                        var parent = expression.parent
+                        while (parent is KtDotQualifiedExpression) {
+                            if (parent.selectorExpression !== expression) {
+                                // Special: package reference in the middle of import directive
+                                // import a.<caret>b.c.SomeClass
+                                // TODO: return reference to PsiPackage
+                                return listOf(expression)
+                            }
+                            parent = parent.parent
+                        }
+                        val classId = fir.resolvedClassId
+                        if (classId != null) {
+                            return listOfNotNull(classId.toTargetPsi(session))
+                        }
+                        val name = fir.importedName ?: return emptyList()
+                        val symbolProvider = session.firSymbolProvider
+                        return symbolProvider.getTopLevelCallableSymbols(fir.packageFqName, name).mapNotNull { it.fir.psi } +
+                                listOfNotNull(symbolProvider.getClassLikeSymbolByFqName(ClassId(fir.packageFqName, name))?.fir?.psi)
+                    }
+                    is FirFile -> {
+                        if (expression.getNonStrictParentOfType<KtPackageDirective>() != null) {
+                            // Special: package reference in the middle of package directive
+                            return listOf(expression)
+                        }
+                        return listOfNotNull(fir.psi)
+                    }
+                    is FirArrayOfCall -> {
+                        // We can't yet find PsiElement for arrayOf, intArrayOf, etc.
+                        return emptyList()
+                    }
+                    is FirErrorNamedReference -> {
+                        return emptyList()
+                    }
+                    else -> {
+                        // Handle situation when we're in the middle/beginning of qualifier
+                        // <caret>A.B.C.foo() or A.<caret>B.C.foo()
+                        // NB: in this case we get some parent FIR, like FirBlock, FirProperty, FirFunction or the like
+                        var parent = expression.parent as? KtDotQualifiedExpression
+                        var unresolvedCounter = 1
+                        while (parent != null) {
+                            val selectorExpression = parent.selectorExpression ?: break
+                            if (selectorExpression === expression) {
+                                parent = parent.parent as? KtDotQualifiedExpression
+                                continue
+                            }
+                            val parentFir = selectorExpression.getOrBuildFir(state)
+                            if (parentFir is FirResolvedQualifier) {
+                                var classId = parentFir.classId
+                                while (unresolvedCounter > 0) {
+                                    unresolvedCounter--
+                                    classId = classId?.outerClassId
+                                }
+                                return listOfNotNull(classId?.toTargetPsi(session))
+                            }
+                            parent = parent.parent as? KtDotQualifiedExpression
+                            unresolvedCounter++
+                        }
+                        return emptyList()
+                    }
+                }
+            }
+        }
+
         class KotlinReferenceResolver : ResolveCache.PolyVariantResolver<AbstractKtReference<KtElement>> {
             class KotlinResolveResult(element: PsiElement) : PsiElementResolveResult(element)
 
             private fun resolveToPsiElements(ref: AbstractKtReference<KtElement>): Collection<PsiElement> {
+                if (FirResolution.enabled) {
+                    return FirReferenceResolveHelper.resolveToPsiElements(ref)
+                }
                 val bindingContext = ref.expression.analyze(BodyResolveMode.PARTIAL)
                 return resolveToPsiElements(ref, bindingContext, ref.getTargetDescriptors(bindingContext))
             }
 
-            private fun resolveToPsiElements(ref: AbstractKtReference<KtElement>, context: BindingContext, targetDescriptors: Collection<DeclarationDescriptor>): Collection<PsiElement> {
+            private fun resolveToPsiElements(
+                ref: AbstractKtReference<KtElement>,
+                context: BindingContext,
+                targetDescriptors: Collection<DeclarationDescriptor>
+            ): Collection<PsiElement> {
                 if (targetDescriptors.isNotEmpty()) {
                     return targetDescriptors.flatMap { target -> resolveToPsiElements(ref, target) }.toSet()
                 }
@@ -95,13 +259,15 @@ abstract class AbstractKtReference<T : KtElement>(element: T) : PsiPolyVariantRe
                 return Collections.emptySet()
             }
 
-            private fun resolveToPsiElements(ref: AbstractKtReference<KtElement>, targetDescriptor: DeclarationDescriptor): Collection<PsiElement> {
+            private fun resolveToPsiElements(
+                ref: AbstractKtReference<KtElement>,
+                targetDescriptor: DeclarationDescriptor
+            ): Collection<PsiElement> {
                 return if (targetDescriptor is PackageViewDescriptor) {
                     val psiFacade = JavaPsiFacade.getInstance(ref.expression.project)
                     val fqName = targetDescriptor.fqName.asString()
                     listOfNotNull(psiFacade.findPackage(fqName))
-                }
+                } else {
-                else {
                     DescriptorToSourceUtilsIde.getAllDeclarations(ref.expression.project, targetDescriptor, ref.expression.resolveScope)
                 }
             }

idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractFirReferenceResolveTest.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.resolve
+
+import org.jetbrains.kotlin.idea.fir.FirResolution
+
+abstract class AbstractFirReferenceResolveTest : AbstractReferenceResolveTest() {
+    override fun setUp() {
+        super.setUp()
+        FirResolution.enabled = true
+    }
+
+    override fun tearDown() {
+        FirResolution.enabled = false
+        super.tearDown()
+    }
+}

idea/tests/org/jetbrains/kotlin/idea/resolve/FirReferenceResolveTestGenerated.java

@@ -0,0 +1,624 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.resolve;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
+import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("idea/testData/resolve/references")
+@TestDataPath("$PROJECT_ROOT")
+@RunWith(JUnit3RunnerWithInners.class)
+public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolveTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+    }
+
+    public void testAllFilesPresentInReferences() throws Exception {
+        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), true);
+    }
+
+    @TestMetadata("AnnotationForClass.kt")
+    public void testAnnotationForClass() throws Exception {
+        runTest("idea/testData/resolve/references/AnnotationForClass.kt");
+    }
+
+    @TestMetadata("AnnotationInsideFunction.kt")
+    public void testAnnotationInsideFunction() throws Exception {
+        runTest("idea/testData/resolve/references/AnnotationInsideFunction.kt");
+    }
+
+    @TestMetadata("AnnotationOnFile.kt")
+    public void testAnnotationOnFile() throws Exception {
+        runTest("idea/testData/resolve/references/AnnotationOnFile.kt");
+    }
+
+    @TestMetadata("AnnotationOnFileWithImport.kt")
+    public void testAnnotationOnFileWithImport() throws Exception {
+        runTest("idea/testData/resolve/references/AnnotationOnFileWithImport.kt");
+    }
+
+    @TestMetadata("AnnotationParameter.kt")
+    public void testAnnotationParameter() throws Exception {
+        runTest("idea/testData/resolve/references/AnnotationParameter.kt");
+    }
+
+    @TestMetadata("AnnotationTypeParameter.kt")
+    public void testAnnotationTypeParameter() throws Exception {
+        runTest("idea/testData/resolve/references/AnnotationTypeParameter.kt");
+    }
+
+    @TestMetadata("ClassInTypeConstraint.kt")
+    public void testClassInTypeConstraint() throws Exception {
+        runTest("idea/testData/resolve/references/ClassInTypeConstraint.kt");
+    }
+
+    @TestMetadata("ClassNameBeforeDot.kt")
+    public void testClassNameBeforeDot() throws Exception {
+        runTest("idea/testData/resolve/references/ClassNameBeforeDot.kt");
+    }
+
+    @TestMetadata("ClassObjectClassLiteralReference.kt")
+    public void testClassObjectClassLiteralReference() throws Exception {
+        runTest("idea/testData/resolve/references/ClassObjectClassLiteralReference.kt");
+    }
+
+    @TestMetadata("ClassObjectClassLiteralReferenceWithField.kt")
+    public void testClassObjectClassLiteralReferenceWithField() throws Exception {
+        runTest("idea/testData/resolve/references/ClassObjectClassLiteralReferenceWithField.kt");
+    }
+
+    @TestMetadata("ClassQualifierForNestedClassConstructorCall.kt")
+    public void testClassQualifierForNestedClassConstructorCall() throws Exception {
+        runTest("idea/testData/resolve/references/ClassQualifierForNestedClassConstructorCall.kt");
+    }
+
+    @TestMetadata("ClassReferenceInImport.kt")
+    public void testClassReferenceInImport() throws Exception {
+        runTest("idea/testData/resolve/references/ClassReferenceInImport.kt");
+    }
+
+    @TestMetadata("CollectionLiteralLeft.kt")
+    public void testCollectionLiteralLeft() throws Exception {
+        runTest("idea/testData/resolve/references/CollectionLiteralLeft.kt");
+    }
+
+    @TestMetadata("CollectionLiteralRight.kt")
+    public void testCollectionLiteralRight() throws Exception {
+        runTest("idea/testData/resolve/references/CollectionLiteralRight.kt");
+    }
+
+    @TestMetadata("CoroutineSuspensionPoint.kt")
+    public void testCoroutineSuspensionPoint() throws Exception {
+        runTest("idea/testData/resolve/references/CoroutineSuspensionPoint.kt");
+    }
+
+    @TestMetadata("CtrlClickResolve.kt")
+    public void testCtrlClickResolve() throws Exception {
+        runTest("idea/testData/resolve/references/CtrlClickResolve.kt");
+    }
+
+    @TestMetadata("DataClassCopy.kt")
+    public void testDataClassCopy() throws Exception {
+        runTest("idea/testData/resolve/references/DataClassCopy.kt");
+    }
+
+    @TestMetadata("DefaultObjectAsExtensionReceiverForFunction.kt")
+    public void testDefaultObjectAsExtensionReceiverForFunction() throws Exception {
+        runTest("idea/testData/resolve/references/DefaultObjectAsExtensionReceiverForFunction.kt");
+    }
+
+    @TestMetadata("DefaultObjectAsExtensionReceiverForProperty.kt")
+    public void testDefaultObjectAsExtensionReceiverForProperty() throws Exception {
+        runTest("idea/testData/resolve/references/DefaultObjectAsExtensionReceiverForProperty.kt");
+    }
+
+    @TestMetadata("DefaultObjectAsReceiverForExtensionFunctionOnSuperType.kt")
+    public void testDefaultObjectAsReceiverForExtensionFunctionOnSuperType() throws Exception {
+        runTest("idea/testData/resolve/references/DefaultObjectAsReceiverForExtensionFunctionOnSuperType.kt");
+    }
+
+    @TestMetadata("DefaultObjectAsReceiverForMemberPropertyInSuperType.kt")
+    public void testDefaultObjectAsReceiverForMemberPropertyInSuperType() throws Exception {
+        runTest("idea/testData/resolve/references/DefaultObjectAsReceiverForMemberPropertyInSuperType.kt");
+    }
+
+    @TestMetadata("DefaultObjectInShortReferenceFormCall.kt")
+    public void testDefaultObjectInShortReferenceFormCall() throws Exception {
+        runTest("idea/testData/resolve/references/DefaultObjectInShortReferenceFormCall.kt");
+    }
+
+    @TestMetadata("EnumValues.kt")
+    public void testEnumValues() throws Exception {
+        runTest("idea/testData/resolve/references/EnumValues.kt");
+    }
+
+    @TestMetadata("FakeJavaLang1.kt")
+    public void testFakeJavaLang1() throws Exception {
+        runTest("idea/testData/resolve/references/FakeJavaLang1.kt");
+    }
+
+    @TestMetadata("FakeJavaLang2.kt")
+    public void testFakeJavaLang2() throws Exception {
+        runTest("idea/testData/resolve/references/FakeJavaLang2.kt");
+    }
+
+    @TestMetadata("FakeJavaLang3.kt")
+    public void testFakeJavaLang3() throws Exception {
+        runTest("idea/testData/resolve/references/FakeJavaLang3.kt");
+    }
+
+    @TestMetadata("FakeJavaLang4.kt")
+    public void testFakeJavaLang4() throws Exception {
+        runTest("idea/testData/resolve/references/FakeJavaLang4.kt");
+    }
+
+    @TestMetadata("fileRefInRawStringLiteral.kt")
+    public void testFileRefInRawStringLiteral() throws Exception {
+        runTest("idea/testData/resolve/references/fileRefInRawStringLiteral.kt");
+    }
+
+    @TestMetadata("fileRefInStringLiteral.kt")
+    public void testFileRefInStringLiteral() throws Exception {
+        runTest("idea/testData/resolve/references/fileRefInStringLiteral.kt");
+    }
+
+    @TestMetadata("GenericFunctionParameter.kt")
+    public void testGenericFunctionParameter() throws Exception {
+        runTest("idea/testData/resolve/references/GenericFunctionParameter.kt");
+    }
+
+    @TestMetadata("GenericTypeInFunctionParameter.kt")
+    public void testGenericTypeInFunctionParameter() throws Exception {
+        runTest("idea/testData/resolve/references/GenericTypeInFunctionParameter.kt");
+    }
+
+    @TestMetadata("ImportFromRootScope.kt")
+    public void testImportFromRootScope() throws Exception {
+        runTest("idea/testData/resolve/references/ImportFromRootScope.kt");
+    }
+
+    @TestMetadata("InClassParameter.kt")
+    public void testInClassParameter() throws Exception {
+        runTest("idea/testData/resolve/references/InClassParameter.kt");
+    }
+
+    @TestMetadata("InClassParameterField.kt")
+    public void testInClassParameterField() throws Exception {
+        runTest("idea/testData/resolve/references/InClassParameterField.kt");
+    }
+
+    @TestMetadata("InEnumEntry.kt")
+    public void testInEnumEntry() throws Exception {
+        runTest("idea/testData/resolve/references/InEnumEntry.kt");
+    }
+
+    @TestMetadata("InFunctionParameterType.kt")
+    public void testInFunctionParameterType() throws Exception {
+        runTest("idea/testData/resolve/references/InFunctionParameterType.kt");
+    }
+
+    @TestMetadata("InMethodParameter.kt")
+    public void testInMethodParameter() throws Exception {
+        runTest("idea/testData/resolve/references/InMethodParameter.kt");
+    }
+
+    @TestMetadata("InObjectClassObject.kt")
+    public void testInObjectClassObject() throws Exception {
+        runTest("idea/testData/resolve/references/InObjectClassObject.kt");
+    }
+
+    @TestMetadata("InSecondClassObject.kt")
+    public void testInSecondClassObject() throws Exception {
+        runTest("idea/testData/resolve/references/InSecondClassObject.kt");
+    }
+
+    @TestMetadata("JavaAnnotationParameter.kt")
+    public void testJavaAnnotationParameter() throws Exception {
+        runTest("idea/testData/resolve/references/JavaAnnotationParameter.kt");
+    }
+
+    @TestMetadata("JavaConstructorNotNullParameter.kt")
+    public void testJavaConstructorNotNullParameter() throws Exception {
+        runTest("idea/testData/resolve/references/JavaConstructorNotNullParameter.kt");
+    }
+
+    @TestMetadata("JavaEnumEntry.kt")
+    public void testJavaEnumEntry() throws Exception {
+        runTest("idea/testData/resolve/references/JavaEnumEntry.kt");
+    }
+
+    @TestMetadata("JavaEnumValueOf.kt")
+    public void testJavaEnumValueOf() throws Exception {
+        runTest("idea/testData/resolve/references/JavaEnumValueOf.kt");
+    }
+
+    @TestMetadata("JavaParameter.kt")
+    public void testJavaParameter() throws Exception {
+        runTest("idea/testData/resolve/references/JavaParameter.kt");
+    }
+
+    @TestMetadata("JavaReference.kt")
+    public void testJavaReference() throws Exception {
+        runTest("idea/testData/resolve/references/JavaReference.kt");
+    }
+
+    @TestMetadata("MultiDeclarationExtension.kt")
+    public void testMultiDeclarationExtension() throws Exception {
+        runTest("idea/testData/resolve/references/MultiDeclarationExtension.kt");
+    }
+
+    @TestMetadata("MultiDeclarationMember.kt")
+    public void testMultiDeclarationMember() throws Exception {
+        runTest("idea/testData/resolve/references/MultiDeclarationMember.kt");
+    }
+
+    @TestMetadata("NamedClassObject.kt")
+    public void testNamedClassObject() throws Exception {
+        runTest("idea/testData/resolve/references/NamedClassObject.kt");
+    }
+
+    @TestMetadata("PackageReference.kt")
+    public void testPackageReference() throws Exception {
+        runTest("idea/testData/resolve/references/PackageReference.kt");
+    }
+
+    @TestMetadata("PackageReferenceInImport.kt")
+    public void testPackageReferenceInImport() throws Exception {
+        runTest("idea/testData/resolve/references/PackageReferenceInImport.kt");
+    }
+
+    @TestMetadata("PropertyPlaceInClassObjectInObject.kt")
+    public void testPropertyPlaceInClassObjectInObject() throws Exception {
+        runTest("idea/testData/resolve/references/PropertyPlaceInClassObjectInObject.kt");
+    }
+
+    @TestMetadata("ReferenceInClassWhereConstraint.kt")
+    public void testReferenceInClassWhereConstraint() throws Exception {
+        runTest("idea/testData/resolve/references/ReferenceInClassWhereConstraint.kt");
+    }
+
+    @TestMetadata("ReferenceInFunWhereConstraint.kt")
+    public void testReferenceInFunWhereConstraint() throws Exception {
+        runTest("idea/testData/resolve/references/ReferenceInFunWhereConstraint.kt");
+    }
+
+    @TestMetadata("ReferenceToSam.kt")
+    public void testReferenceToSam() throws Exception {
+        runTest("idea/testData/resolve/references/ReferenceToSam.kt");
+    }
+
+    @TestMetadata("ResolveClass.kt")
+    public void testResolveClass() throws Exception {
+        runTest("idea/testData/resolve/references/ResolveClass.kt");
+    }
+
+    @TestMetadata("ResolvePackageInProperty.kt")
+    public void testResolvePackageInProperty() throws Exception {
+        runTest("idea/testData/resolve/references/ResolvePackageInProperty.kt");
+    }
+
+    @TestMetadata("SamAdapter.kt")
+    public void testSamAdapter() throws Exception {
+        runTest("idea/testData/resolve/references/SamAdapter.kt");
+    }
+
+    @TestMetadata("SamConstructor.kt")
+    public void testSamConstructor() throws Exception {
+        runTest("idea/testData/resolve/references/SamConstructor.kt");
+    }
+
+    @TestMetadata("SamConstructorTypeArguments.kt")
+    public void testSamConstructorTypeArguments() throws Exception {
+        runTest("idea/testData/resolve/references/SamConstructorTypeArguments.kt");
+    }
+
+    @TestMetadata("SeveralOverrides.kt")
+    public void testSeveralOverrides() throws Exception {
+        runTest("idea/testData/resolve/references/SeveralOverrides.kt");
+    }
+
+    @TestMetadata("SyntheticProperty.kt")
+    public void testSyntheticProperty() throws Exception {
+        runTest("idea/testData/resolve/references/SyntheticProperty.kt");
+    }
+
+    @TestMetadata("TypeAlias.kt")
+    public void testTypeAlias() throws Exception {
+        runTest("idea/testData/resolve/references/TypeAlias.kt");
+    }
+
+    @TestMetadata("TypeAliasAsSupertypeConstructor.kt")
+    public void testTypeAliasAsSupertypeConstructor() throws Exception {
+        runTest("idea/testData/resolve/references/TypeAliasAsSupertypeConstructor.kt");
+    }
+
+    @TestMetadata("TypeAliasRHS.kt")
+    public void testTypeAliasRHS() throws Exception {
+        runTest("idea/testData/resolve/references/TypeAliasRHS.kt");
+    }
+
+    @TestMetadata("TypeArgumentBeforeDot.kt")
+    public void testTypeArgumentBeforeDot() throws Exception {
+        runTest("idea/testData/resolve/references/TypeArgumentBeforeDot.kt");
+    }
+
+    @TestMetadata("TypeArgumentBeforeDot2.kt")
+    public void testTypeArgumentBeforeDot2() throws Exception {
+        runTest("idea/testData/resolve/references/TypeArgumentBeforeDot2.kt");
+    }
+
+    @TestMetadata("TypeArgumentUnresolvedClass.kt")
+    public void testTypeArgumentUnresolvedClass() throws Exception {
+        runTest("idea/testData/resolve/references/TypeArgumentUnresolvedClass.kt");
+    }
+
+    @TestMetadata("TypeArgumentUnresolvedConstructor.kt")
+    public void testTypeArgumentUnresolvedConstructor() throws Exception {
+        runTest("idea/testData/resolve/references/TypeArgumentUnresolvedConstructor.kt");
+    }
+
+    @TestMetadata("TypeArgumentWrongNumber.kt")
+    public void testTypeArgumentWrongNumber() throws Exception {
+        runTest("idea/testData/resolve/references/TypeArgumentWrongNumber.kt");
+    }
+
+    @TestMetadata("TypeParameterInAnonymousObject.kt")
+    public void testTypeParameterInAnonymousObject() throws Exception {
+        runTest("idea/testData/resolve/references/TypeParameterInAnonymousObject.kt");
+    }
+
+    @TestMetadata("TypeParameterInFunctionLiteral.kt")
+    public void testTypeParameterInFunctionLiteral() throws Exception {
+        runTest("idea/testData/resolve/references/TypeParameterInFunctionLiteral.kt");
+    }
+
+    @TestMetadata("ValueParameter.kt")
+    public void testValueParameter() throws Exception {
+        runTest("idea/testData/resolve/references/ValueParameter.kt");
+    }
+
+    @TestMetadata("WrongNumberOfTypeArguments.kt")
+    public void testWrongNumberOfTypeArguments() throws Exception {
+        runTest("idea/testData/resolve/references/WrongNumberOfTypeArguments.kt");
+    }
+
+    @TestMetadata("WrongNumberOfTypeArguments2.kt")
+    public void testWrongNumberOfTypeArguments2() throws Exception {
+        runTest("idea/testData/resolve/references/WrongNumberOfTypeArguments2.kt");
+    }
+
+    @TestMetadata("WrongNumberOfTypeArgumentsInSupertype.kt")
+    public void testWrongNumberOfTypeArgumentsInSupertype() throws Exception {
+        runTest("idea/testData/resolve/references/WrongNumberOfTypeArgumentsInSupertype.kt");
+    }
+
+    @TestMetadata("idea/testData/resolve/references/delegatedPropertyAccessors")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class DelegatedPropertyAccessors extends AbstractFirReferenceResolveTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInDelegatedPropertyAccessors() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors"), Pattern.compile("^([^.]+)\\.kt$"), true);
+        }
+
+        @TestMetadata("unresolved.kt")
+        public void testUnresolved() throws Exception {
+            runTest("idea/testData/resolve/references/delegatedPropertyAccessors/unresolved.kt");
+        }
+
+        @TestMetadata("idea/testData/resolve/references/delegatedPropertyAccessors/inSource")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class InSource extends AbstractFirReferenceResolveTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInInSource() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inSource"), Pattern.compile("^([^.]+)\\.kt$"), true);
+            }
+
+            @TestMetadata("getExtension.kt")
+            public void testGetExtension() throws Exception {
+                runTest("idea/testData/resolve/references/delegatedPropertyAccessors/inSource/getExtension.kt");
+            }
+
+            @TestMetadata("getMember.kt")
+            public void testGetMember() throws Exception {
+                runTest("idea/testData/resolve/references/delegatedPropertyAccessors/inSource/getMember.kt");
+            }
+
+            @TestMetadata("getMultipleDeclarations.kt")
+            public void testGetMultipleDeclarations() throws Exception {
+                runTest("idea/testData/resolve/references/delegatedPropertyAccessors/inSource/getMultipleDeclarations.kt");
+            }
+
+            @TestMetadata("getOneFakeOverride.kt")
+            public void testGetOneFakeOverride() throws Exception {
+                runTest("idea/testData/resolve/references/delegatedPropertyAccessors/inSource/getOneFakeOverride.kt");
+            }
+        }
+
+        @TestMetadata("idea/testData/resolve/references/delegatedPropertyAccessors/inStandardLibrary")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class InStandardLibrary extends AbstractFirReferenceResolveTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInInStandardLibrary() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inStandardLibrary"), Pattern.compile("^([^.]+)\\.kt$"), true);
+            }
+
+            @TestMetadata("lazy.kt")
+            public void testLazy() throws Exception {
+                runTest("idea/testData/resolve/references/delegatedPropertyAccessors/inStandardLibrary/lazy.kt");
+            }
+
+            @TestMetadata("notNull.kt")
+            public void testNotNull() throws Exception {
+                runTest("idea/testData/resolve/references/delegatedPropertyAccessors/inStandardLibrary/notNull.kt");
+            }
+        }
+    }
+
+    @TestMetadata("idea/testData/resolve/references/forLoopIn")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class ForLoopIn extends AbstractFirReferenceResolveTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInForLoopIn() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/references/forLoopIn"), Pattern.compile("^([^.]+)\\.kt$"), true);
+        }
+
+        @TestMetadata("unresolvedIterator.kt")
+        public void testUnresolvedIterator() throws Exception {
+            runTest("idea/testData/resolve/references/forLoopIn/unresolvedIterator.kt");
+        }
+
+        @TestMetadata("idea/testData/resolve/references/forLoopIn/inBuiltIns")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class InBuiltIns extends AbstractFirReferenceResolveTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInInBuiltIns() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inBuiltIns"), Pattern.compile("^([^.]+)\\.kt$"), true);
+            }
+
+            @TestMetadata("extension.kt")
+            public void testExtension() throws Exception {
+                runTest("idea/testData/resolve/references/forLoopIn/inBuiltIns/extension.kt");
+            }
+
+            @TestMetadata("member.kt")
+            public void testMember() throws Exception {
+                runTest("idea/testData/resolve/references/forLoopIn/inBuiltIns/member.kt");
+            }
+        }
+
+        @TestMetadata("idea/testData/resolve/references/forLoopIn/inLibrary")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class InLibrary extends AbstractFirReferenceResolveTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInInLibrary() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inLibrary"), Pattern.compile("^([^.]+)\\.kt$"), true);
+            }
+
+            @TestMetadata("extension.kt")
+            public void testExtension() throws Exception {
+                runTest("idea/testData/resolve/references/forLoopIn/inLibrary/extension.kt");
+            }
+        }
+
+        @TestMetadata("idea/testData/resolve/references/forLoopIn/inSource")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class InSource extends AbstractFirReferenceResolveTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            @TestMetadata("allExtensions.kt")
+            public void testAllExtensions() throws Exception {
+                runTest("idea/testData/resolve/references/forLoopIn/inSource/allExtensions.kt");
+            }
+
+            public void testAllFilesPresentInInSource() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inSource"), Pattern.compile("^([^.]+)\\.kt$"), true);
+            }
+
+            @TestMetadata("allMembers.kt")
+            public void testAllMembers() throws Exception {
+                runTest("idea/testData/resolve/references/forLoopIn/inSource/allMembers.kt");
+            }
+
+            @TestMetadata("nextMissing.kt")
+            public void testNextMissing() throws Exception {
+                runTest("idea/testData/resolve/references/forLoopIn/inSource/nextMissing.kt");
+            }
+        }
+    }
+
+    @TestMetadata("idea/testData/resolve/references/invoke")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Invoke extends AbstractFirReferenceResolveTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInInvoke() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/resolve/references/invoke"), Pattern.compile("^([^.]+)\\.kt$"), true);
+        }
+
+        @TestMetadata("lambdaAndParens.kt")
+        public void testLambdaAndParens() throws Exception {
+            runTest("idea/testData/resolve/references/invoke/lambdaAndParens.kt");
+        }
+
+        @TestMetadata("lambdaNoPar.kt")
+        public void testLambdaNoPar() throws Exception {
+            runTest("idea/testData/resolve/references/invoke/lambdaNoPar.kt");
+        }
+
+        @TestMetadata("lambdaNoParLabel.kt")
+        public void testLambdaNoParLabel() throws Exception {
+            runTest("idea/testData/resolve/references/invoke/lambdaNoParLabel.kt");
+        }
+
+        @TestMetadata("lambdaNoParRCurly.kt")
+        public void testLambdaNoParRCurly() throws Exception {
+            runTest("idea/testData/resolve/references/invoke/lambdaNoParRCurly.kt");
+        }
+
+        @TestMetadata("noParams.kt")
+        public void testNoParams() throws Exception {
+            runTest("idea/testData/resolve/references/invoke/noParams.kt");
+        }
+
+        @TestMetadata("noParamsRPar.kt")
+        public void testNoParamsRPar() throws Exception {
+            runTest("idea/testData/resolve/references/invoke/noParamsRPar.kt");
+        }
+
+        @TestMetadata("nonemptyLambdaRPar.kt")
+        public void testNonemptyLambdaRPar() throws Exception {
+            runTest("idea/testData/resolve/references/invoke/nonemptyLambdaRPar.kt");
+        }
+
+        @TestMetadata("oneParam.kt")
+        public void testOneParam() throws Exception {
+            runTest("idea/testData/resolve/references/invoke/oneParam.kt");
+        }
+
+        @TestMetadata("oneParamRPar.kt")
+        public void testOneParamRPar() throws Exception {
+            runTest("idea/testData/resolve/references/invoke/oneParamRPar.kt");
+        }
+    }
+}