From 78200dd38e5c11b8d711c28921fbaa0ec5d790a7 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 23 Apr 2019 17:25:03 +0300 Subject: [PATCH] Get Kotlin references through Kotlin contributors only (KT-31129) Speed up getting references and protect Kotlin from slow references contributors. #KT-31129 Fixed --- .../kotlin/kdoc/psi/impl/KDocLink.kt | 6 - .../psi/KotlinReferenceProvidersService.kt | 28 +++++ .../kotlin/psi/KtBlockExpression.java | 8 +- .../jetbrains/kotlin/psi/KtElementImpl.java | 8 +- .../kotlin/psi/KtElementImplStub.java | 3 +- .../psi/KtStringTemplateExpression.java | 8 +- .../test/testFramework/KtParsingTestCase.java | 3 - ...ationMethodImplicitReferenceContributor.kt | 90 +++++++------- .../references/KotlinReferenceContributor.kt | 23 ++-- .../KtIdeReferenceProviderService.kt | 111 ++++++++++++++++++ idea/resources/META-INF/plugin-common.xml | 8 +- ...onMethodKotlinImplicitReferenceSearcher.kt | 2 +- 12 files changed, 214 insertions(+), 84 deletions(-) create mode 100644 compiler/psi/src/org/jetbrains/kotlin/psi/KotlinReferenceProvidersService.kt create mode 100644 idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtIdeReferenceProviderService.kt diff --git a/compiler/psi/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt b/compiler/psi/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt index 6955e4e772e..887f7611e98 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt +++ b/compiler/psi/src/org/jetbrains/kotlin/kdoc/psi/impl/KDocLink.kt @@ -18,10 +18,7 @@ package org.jetbrains.kotlin.kdoc.psi.impl import com.intellij.lang.ASTNode import com.intellij.openapi.util.TextRange -import com.intellij.psi.PsiReference -import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry import org.jetbrains.kotlin.psi.KtElementImpl -import org.jetbrains.kotlin.kdoc.psi.api.KDoc import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType class KDocLink(node: ASTNode) : KtElementImpl(node) { @@ -42,7 +39,4 @@ class KDocLink(node: ASTNode) : KtElementImpl(node) { val tag = getStrictParentOfType() return if (tag != null && tag.getSubjectLink() == this) tag else null } - - override fun getReferences(): Array = - ReferenceProvidersRegistry.getReferencesFromProviders(this) } diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KotlinReferenceProvidersService.kt b/compiler/psi/src/org/jetbrains/kotlin/psi/KotlinReferenceProvidersService.kt new file mode 100644 index 00000000000..3195bea0909 --- /dev/null +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KotlinReferenceProvidersService.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. 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.psi + +import com.intellij.openapi.components.ServiceManager +import com.intellij.psi.PsiElement +import com.intellij.psi.PsiReference + +open class KotlinReferenceProvidersService { + open fun getReferences(psiElement: PsiElement): Array = PsiReference.EMPTY_ARRAY + + companion object { + private val NO_REFERENCES_SERVICE = KotlinReferenceProvidersService() + + @JvmStatic + fun getInstance(): KotlinReferenceProvidersService { + return ServiceManager.getService(KotlinReferenceProvidersService::class.java) ?: NO_REFERENCES_SERVICE + } + + @JvmStatic + fun getReferencesFromProviders(psiElement: PsiElement): Array { + return getInstance().getReferences(psiElement) + } + } +} \ No newline at end of file diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtBlockExpression.java b/compiler/psi/src/org/jetbrains/kotlin/psi/KtBlockExpression.java index 8c924848db8..2c7b4f8848f 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtBlockExpression.java +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtBlockExpression.java @@ -18,8 +18,10 @@ package org.jetbrains.kotlin.psi; import com.intellij.lang.Language; import com.intellij.openapi.util.TextRange; -import com.intellij.psi.*; -import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiElementVisitor; +import com.intellij.psi.PsiModifiableCodeBlock; +import com.intellij.psi.PsiReference; import com.intellij.psi.impl.source.tree.CompositeElement; import com.intellij.psi.impl.source.tree.LazyParseablePsiElement; import com.intellij.psi.util.PsiUtilCore; @@ -121,7 +123,7 @@ public class KtBlockExpression extends LazyParseablePsiElement implements KtElem @NotNull @Override public PsiReference[] getReferences() { - return ReferenceProvidersRegistry.getReferencesFromProviders(this, PsiReferenceService.Hints.NO_HINTS); + return KotlinReferenceProvidersService.getReferencesFromProviders(this); } @NotNull diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtElementImpl.java b/compiler/psi/src/org/jetbrains/kotlin/psi/KtElementImpl.java index fca63562e34..648c44b6a1f 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtElementImpl.java +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtElementImpl.java @@ -19,8 +19,10 @@ package org.jetbrains.kotlin.psi; import com.intellij.extapi.psi.ASTWrapperPsiElement; import com.intellij.lang.ASTNode; import com.intellij.lang.Language; -import com.intellij.psi.*; -import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiElementVisitor; +import com.intellij.psi.PsiFile; +import com.intellij.psi.PsiReference; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.idea.KotlinLanguage; @@ -92,7 +94,7 @@ public class KtElementImpl extends ASTWrapperPsiElement implements KtElement { @NotNull @Override public PsiReference[] getReferences() { - return ReferenceProvidersRegistry.getReferencesFromProviders(this, PsiReferenceService.Hints.NO_HINTS); + return KotlinReferenceProvidersService.getReferencesFromProviders(this); } @NotNull diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtElementImplStub.java b/compiler/psi/src/org/jetbrains/kotlin/psi/KtElementImplStub.java index 9c108ce147c..0b4e3ffcf45 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtElementImplStub.java +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtElementImplStub.java @@ -20,7 +20,6 @@ import com.intellij.extapi.psi.StubBasedPsiElementBase; import com.intellij.lang.ASTNode; import com.intellij.lang.Language; import com.intellij.psi.*; -import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry; import com.intellij.psi.stubs.IStubElementType; import com.intellij.psi.stubs.StubElement; import com.intellij.util.IncorrectOperationException; @@ -109,7 +108,7 @@ public class KtElementImplStub> extends StubBasedPsiEle @NotNull @Override public PsiReference[] getReferences() { - return ReferenceProvidersRegistry.getReferencesFromProviders(this, PsiReferenceService.Hints.NO_HINTS); + return KotlinReferenceProvidersService.getReferencesFromProviders(this); } @NotNull diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtStringTemplateExpression.java b/compiler/psi/src/org/jetbrains/kotlin/psi/KtStringTemplateExpression.java index b9c64061aa2..af58a1b8c23 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtStringTemplateExpression.java +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtStringTemplateExpression.java @@ -17,10 +17,7 @@ package org.jetbrains.kotlin.psi; import com.intellij.lang.ASTNode; -import com.intellij.psi.ElementManipulators; -import com.intellij.psi.LiteralTextEscaper; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiLanguageInjectionHost; +import com.intellij.psi.*; import com.intellij.psi.tree.TokenSet; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; @@ -28,7 +25,8 @@ import org.jetbrains.kotlin.lexer.KtTokens; import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub; import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes; -public class KtStringTemplateExpression extends KtElementImplStub> implements KtExpression, PsiLanguageInjectionHost { +public class KtStringTemplateExpression extends KtElementImplStub> + implements KtExpression, PsiLanguageInjectionHost, ContributedReferenceHost { private static final TokenSet CLOSE_QUOTE_TOKEN_SET = TokenSet.create(KtTokens.CLOSING_QUOTE); public KtStringTemplateExpression(@NotNull ASTNode node) { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/testFramework/KtParsingTestCase.java b/compiler/tests-common/tests/org/jetbrains/kotlin/test/testFramework/KtParsingTestCase.java index ffc6ea62171..8e34c41a923 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/testFramework/KtParsingTestCase.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/testFramework/KtParsingTestCase.java @@ -43,8 +43,6 @@ import com.intellij.pom.core.impl.PomModelImpl; import com.intellij.pom.tree.TreeAspect; import com.intellij.psi.*; import com.intellij.psi.impl.*; -import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry; -import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistryImpl; import com.intellij.psi.util.CachedValuesManager; import com.intellij.testFramework.LightVirtualFile; import com.intellij.testFramework.TestDataFile; @@ -109,7 +107,6 @@ public abstract class KtParsingTestCase extends KtPlatformLiteFixture { registerComponentInstance(appContainer, PsiDocumentManager.class, new MockPsiDocumentManager()); registerApplicationService(PsiBuilderFactory.class, new PsiBuilderFactoryImpl()); registerApplicationService(DefaultASTFactory.class, new CoreASTFactory()); - registerApplicationService(ReferenceProvidersRegistry.class, new ReferenceProvidersRegistryImpl()); registerApplicationService(ProgressManager.class, new CoreProgressManager()); diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinDefaultAnnotationMethodImplicitReferenceContributor.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinDefaultAnnotationMethodImplicitReferenceContributor.kt index 027e8ff41f3..a58446bef9a 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinDefaultAnnotationMethodImplicitReferenceContributor.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinDefaultAnnotationMethodImplicitReferenceContributor.kt @@ -16,58 +16,58 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.* -class KotlinDefaultAnnotationMethodImplicitReferenceContributor : AbstractKotlinReferenceContributor() { - class ReferenceImpl(private val argument: KtValueArgument) : PsiReference { - private fun resolveAnnotationCallee(): PsiElement? = argument.getStrictParentOfType() - ?.calleeExpression - ?.constructorReferenceExpression - ?.mainReference - ?.resolve() +class ReferenceImpl(private val argument: KtValueArgument) : PsiReference { + private fun resolveAnnotationCallee(): PsiElement? = argument.getStrictParentOfType() + ?.calleeExpression + ?.constructorReferenceExpression + ?.mainReference + ?.resolve() - override fun getElement() = argument + override fun getElement() = argument - override fun getRangeInElement() = TextRange.EMPTY_RANGE + override fun getRangeInElement() = TextRange.EMPTY_RANGE - override fun resolve(): PsiElement? { - val annotationPsi = resolveAnnotationCallee() ?: return null - val name = PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME - return when (annotationPsi) { - is PsiClass -> { - val signature = MethodSignatureUtil.createMethodSignature( - name, PsiType.EMPTY_ARRAY, PsiTypeParameter.EMPTY_ARRAY, PsiSubstitutor.EMPTY - ) - MethodSignatureUtil.findMethodBySignature(annotationPsi, signature, false) - } - is KtPrimaryConstructor -> annotationPsi.containingClassOrObject?.findPropertyByName(name) as? KtParameter - else -> null + override fun resolve(): PsiElement? { + val annotationPsi = resolveAnnotationCallee() ?: return null + val name = PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME + return when (annotationPsi) { + is PsiClass -> { + val signature = MethodSignatureUtil.createMethodSignature( + name, PsiType.EMPTY_ARRAY, PsiTypeParameter.EMPTY_ARRAY, PsiSubstitutor.EMPTY + ) + MethodSignatureUtil.findMethodBySignature(annotationPsi, signature, false) } + is KtPrimaryConstructor -> annotationPsi.containingClassOrObject?.findPropertyByName(name) as? KtParameter + else -> null } - - override fun getCanonicalText() = PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME - - override fun handleElementRename(newElementName: String): PsiElement { - val psiFactory = KtPsiFactory(argument) - val newArgument = psiFactory.createArgument( - argument.getArgumentExpression(), - Name.identifier(newElementName.quoteIfNeeded()), - argument.getSpreadElement() != null - ) - return argument.replaced(newArgument) - } - - override fun bindToElement(element: PsiElement) = throw IncorrectOperationException("Not implemented") - - override fun isReferenceTo(element: PsiElement): Boolean { - val unwrapped = element.unwrapped - return (unwrapped is PsiMethod || unwrapped is KtParameter) && unwrapped == resolve() - } - - override fun getVariants() = ArrayUtil.EMPTY_OBJECT_ARRAY - - override fun isSoft() = false } - override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) { + override fun getCanonicalText() = PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME + + override fun handleElementRename(newElementName: String): PsiElement { + val psiFactory = KtPsiFactory(argument) + val newArgument = psiFactory.createArgument( + argument.getArgumentExpression(), + Name.identifier(newElementName.quoteIfNeeded()), + argument.getSpreadElement() != null + ) + return argument.replaced(newArgument) + } + + override fun bindToElement(element: PsiElement) = throw IncorrectOperationException("Not implemented") + + override fun isReferenceTo(element: PsiElement): Boolean { + val unwrapped = element.unwrapped + return (unwrapped is PsiMethod || unwrapped is KtParameter) && unwrapped == resolve() + } + + override fun getVariants() = ArrayUtil.EMPTY_OBJECT_ARRAY + + override fun isSoft() = false +} + +internal class KotlinDefaultAnnotationMethodImplicitReferenceContributor : KotlinReferenceProviderContributor { + override fun registerReferenceProviders(registrar: KotlinPsiReferenceRegistrar) { registrar.registerProvider { if (it.isNamed()) return@registerProvider null val annotationEntry = it.getParentOfTypeAndBranch { valueArgumentList } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinReferenceContributor.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinReferenceContributor.kt index e0469dfb71d..4a0a505b436 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinReferenceContributor.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinReferenceContributor.kt @@ -16,8 +16,6 @@ package org.jetbrains.kotlin.idea.references -import com.intellij.psi.PsiReference -import com.intellij.psi.PsiReferenceRegistrar import org.jetbrains.kotlin.idea.kdoc.KDocReference import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi.KtImportDirective @@ -26,24 +24,27 @@ import org.jetbrains.kotlin.psi.KtPackageDirective import org.jetbrains.kotlin.psi.KtUserType import org.jetbrains.kotlin.psi.psiUtil.parents -class KotlinReferenceContributor() : AbstractKotlinReferenceContributor() { - override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) { +internal class KotlinReferenceContributor : KotlinReferenceProviderContributor { + override fun registerReferenceProviders(registrar: KotlinPsiReferenceRegistrar) { with(registrar) { registerProvider(factory = ::KtSimpleNameReference) - registerMultiProvider { - if (it.getReferencedNameElementType() != KtTokens.IDENTIFIER) return@registerMultiProvider emptyArray() - if (it.parents.any { it is KtImportDirective || it is KtPackageDirective || it is KtUserType }) { + registerMultiProvider { nameReferenceExpression -> + if (nameReferenceExpression.getReferencedNameElementType() != KtTokens.IDENTIFIER) return@registerMultiProvider emptyArray() + if (nameReferenceExpression.parents.any { it is KtImportDirective || it is KtPackageDirective || it is KtUserType }) { return@registerMultiProvider emptyArray() } - when (it.readWriteAccess(useResolveForReadWrite = false)) { + when (nameReferenceExpression.readWriteAccess(useResolveForReadWrite = false)) { ReferenceAccess.READ -> - arrayOf(SyntheticPropertyAccessorReference.Getter(it)) + arrayOf(SyntheticPropertyAccessorReference.Getter(nameReferenceExpression)) ReferenceAccess.WRITE -> - arrayOf(SyntheticPropertyAccessorReference.Setter(it)) + arrayOf(SyntheticPropertyAccessorReference.Setter(nameReferenceExpression)) ReferenceAccess.READ_WRITE -> - arrayOf(SyntheticPropertyAccessorReference.Getter(it), SyntheticPropertyAccessorReference.Setter(it)) + arrayOf( + SyntheticPropertyAccessorReference.Getter(nameReferenceExpression), + SyntheticPropertyAccessorReference.Setter(nameReferenceExpression) + ) } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtIdeReferenceProviderService.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtIdeReferenceProviderService.kt new file mode 100644 index 00000000000..7cb850980d0 --- /dev/null +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtIdeReferenceProviderService.kt @@ -0,0 +1,111 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. 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.references + +import com.intellij.openapi.project.IndexNotReadyException +import com.intellij.psi.ContributedReferenceHost +import com.intellij.psi.PsiElement +import com.intellij.psi.PsiReference +import com.intellij.psi.PsiReferenceService +import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry +import com.intellij.psi.util.CachedValueProvider +import com.intellij.psi.util.CachedValuesManager +import com.intellij.psi.util.PsiModificationTracker +import com.intellij.util.containers.ConcurrentFactoryMap +import com.intellij.util.containers.ContainerUtil +import com.intellij.util.containers.MultiMap +import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService +import org.jetbrains.kotlin.psi.KtElement +import org.jetbrains.kotlin.utils.SmartList + +internal interface KotlinPsiReferenceProvider { + fun getReferencesByElement(element: PsiElement): Array +} + +internal interface KotlinReferenceProviderContributor { + fun registerReferenceProviders(registrar: KotlinPsiReferenceRegistrar) +} + +internal class KotlinPsiReferenceRegistrar { + val providers: MultiMap, KotlinPsiReferenceProvider> = MultiMap.create() + + inline fun registerProvider(crossinline factory: (E) -> PsiReference?) { + registerMultiProvider { element -> + factory(element)?.let { reference -> arrayOf(reference) } ?: PsiReference.EMPTY_ARRAY + } + } + + inline fun registerMultiProvider(crossinline factory: (E) -> Array) { + val provider: KotlinPsiReferenceProvider = object : KotlinPsiReferenceProvider { + override fun getReferencesByElement(element: PsiElement): Array { + @Suppress("UNCHECKED_CAST") + return factory(element as E) + } + } + + registerMultiProvider(E::class.java, provider) + } + + fun registerMultiProvider(klass: Class, provider: KotlinPsiReferenceProvider) { + providers.putValue(klass, provider) + } +} + +class KtIdeReferenceProviderService : KotlinReferenceProvidersService() { + private val originalProvidersBinding: MultiMap, KotlinPsiReferenceProvider> + private val providersBindingCache: Map, List> + + private val referenceContributors = listOf(KotlinReferenceContributor(), KotlinDefaultAnnotationMethodImplicitReferenceContributor()) + + init { + val registrar = KotlinPsiReferenceRegistrar() + referenceContributors.forEach { it.registerReferenceProviders(registrar) } + originalProvidersBinding = registrar.providers + + providersBindingCache = ConcurrentFactoryMap.createMap, List> { klass -> + val result = ContainerUtil.newSmartList() + for (bindingClass in originalProvidersBinding.keySet()) { + if (bindingClass.isAssignableFrom(klass)) { + result.addAll(originalProvidersBinding.get(bindingClass)) + } + } + result + } + } + + private fun doGetKotlinReferencesFromProviders(context: PsiElement): Array { + val providers: List? = providersBindingCache[context.javaClass] + if (providers.isNullOrEmpty()) return PsiReference.EMPTY_ARRAY + + val result = SmartList() + for (provider in providers) { + try { + result.addAll(provider.getReferencesByElement(context)) + } catch (ignored: IndexNotReadyException) { + // Ignore and continue to next provider + } + } + + if (result.isEmpty()) { + return PsiReference.EMPTY_ARRAY + } + + return result.toTypedArray() + } + + override fun getReferences(psiElement: PsiElement): Array { + if (psiElement is ContributedReferenceHost) { + return ReferenceProvidersRegistry.getReferencesFromProviders(psiElement, PsiReferenceService.Hints.NO_HINTS) + } + + return CachedValuesManager.getCachedValue(psiElement) { + CachedValueProvider.Result.create( + doGetKotlinReferencesFromProviders(psiElement), + PsiModificationTracker.MODIFICATION_COUNT + ) + } + } +} \ No newline at end of file diff --git a/idea/resources/META-INF/plugin-common.xml b/idea/resources/META-INF/plugin-common.xml index fbd9e63a18a..c0999805cca 100644 --- a/idea/resources/META-INF/plugin-common.xml +++ b/idea/resources/META-INF/plugin-common.xml @@ -224,6 +224,9 @@ + + @@ -523,15 +526,10 @@ - - diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/DefaultAnnotationMethodKotlinImplicitReferenceSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/DefaultAnnotationMethodKotlinImplicitReferenceSearcher.kt index 54a07f007ac..3a19b057128 100644 --- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/DefaultAnnotationMethodKotlinImplicitReferenceSearcher.kt +++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/DefaultAnnotationMethodKotlinImplicitReferenceSearcher.kt @@ -32,7 +32,7 @@ import org.jetbrains.kotlin.psi.KtAnnotationEntry import org.jetbrains.kotlin.psi.KtValueArgument import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull -import org.jetbrains.kotlin.idea.references.KotlinDefaultAnnotationMethodImplicitReferenceContributor.ReferenceImpl as ImplicitReference +import org.jetbrains.kotlin.idea.references.ReferenceImpl as ImplicitReference class DefaultAnnotationMethodKotlinImplicitReferenceSearcher : QueryExecutorBase(true) {