diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index e5f4dc3ec31..d638acb1694 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/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) { model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) } + testClass { + model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) + } + testClass { model("resolve/referenceInJava/binaryAndSource", extension = "java") model("resolve/referenceInJava/sourceOnly", extension = "java") diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.183 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.183 index 4b7481365c8..5e6fc515dc4 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.183 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.183 @@ -502,6 +502,10 @@ fun main(args: Array) { model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) } + testClass { + model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) + } + testClass { model("resolve/referenceInJava/binaryAndSource", extension = "java") model("resolve/referenceInJava/sourceOnly", extension = "java") diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as34 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as34 index f1dae257b1c..4653d5cdc5f 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as34 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as34 @@ -490,6 +490,10 @@ fun main(args: Array) { model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) } + testClass { + model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) + } + testClass { model("resolve/referenceInJava/binaryAndSource", extension = "java") model("resolve/referenceInJava/sourceOnly", extension = "java") diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as35 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as35 index f1dae257b1c..4653d5cdc5f 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as35 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as35 @@ -490,6 +490,10 @@ fun main(args: Array) { model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) } + testClass { + model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) + } + testClass { model("resolve/referenceInJava/binaryAndSource", extension = "java") model("resolve/referenceInJava/sourceOnly", extension = "java") diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as36 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as36 index f1dae257b1c..4653d5cdc5f 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as36 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as36 @@ -490,6 +490,10 @@ fun main(args: Array) { model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) } + testClass { + model("resolve/references", pattern = KT_WITHOUT_DOTS_IN_NAME) + } + testClass { model("resolve/referenceInJava/binaryAndSource", extension = "java") model("resolve/referenceInJava/sourceOnly", extension = "java") diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtReference.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtReference.kt index 5ae9f034732..0235989290f 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtReference.kt +++ b/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(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): Collection { + 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.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() != 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 + // A.B.C.foo() or A.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> { class KotlinResolveResult(element: PsiElement) : PsiElementResolveResult(element) private fun resolveToPsiElements(ref: AbstractKtReference): Collection { + 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, context: BindingContext, targetDescriptors: Collection): Collection { + private fun resolveToPsiElements( + ref: AbstractKtReference, + context: BindingContext, + targetDescriptors: Collection + ): Collection { if (targetDescriptors.isNotEmpty()) { return targetDescriptors.flatMap { target -> resolveToPsiElements(ref, target) }.toSet() } @@ -95,13 +259,15 @@ abstract class AbstractKtReference(element: T) : PsiPolyVariantRe return Collections.emptySet() } - private fun resolveToPsiElements(ref: AbstractKtReference, targetDescriptor: DeclarationDescriptor): Collection { + private fun resolveToPsiElements( + ref: AbstractKtReference, + targetDescriptor: DeclarationDescriptor + ): Collection { 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) } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractFirReferenceResolveTest.kt b/idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractFirReferenceResolveTest.kt new file mode 100644 index 00000000000..bb0a9317016 --- /dev/null +++ b/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() + } +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/FirReferenceResolveTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/FirReferenceResolveTestGenerated.java new file mode 100644 index 00000000000..2112d63242c --- /dev/null +++ b/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"); + } + } +}