Classify Location.NO_LOCATION usages

idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.idea.imports.canBeReferencedViaImport
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.JETBRAINS_NULLABLE_ANNOTATION
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.JETBRAINS_READONLY_ANNOTATION
@@ -81,7 +82,7 @@ fun JetType.isResolvableInScope(scope: JetScope?, checkTypeParameters: Boolean):
     if (descriptor == null || descriptor.getName().isSpecial()) return false
     if (!checkTypeParameters && descriptor is TypeParameterDescriptor) return true
 
-    return scope != null && scope.getClassifier(descriptor.getName()) == descriptor
+    return scope != null && scope.getClassifier(descriptor.name, LookupLocation.NO_LOCATION_FROM_IDE) == descriptor
 }
 
 public fun JetType.approximateWithResolvableType(scope: JetScope?, checkTypeParameters: Boolean): JetType {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.java

@@ -140,7 +140,7 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport
                 if (declaration instanceof JetFunction) {
                     JetFunction jetFunction = (JetFunction) declaration;
                     Name name = jetFunction.getNameAsSafeName();
-                    Collection<FunctionDescriptor> functions = packageDescriptor.getMemberScope().getFunctions(name, LookupLocation.NO_LOCATION);
+                    Collection<FunctionDescriptor> functions = packageDescriptor.getMemberScope().getFunctions(name, LookupLocation.NO_LOCATION_FROM_IDE);
                     for (FunctionDescriptor descriptor : functions) {
                         ForceResolveUtil.forceResolveAllContents(descriptor);
                     }
@@ -148,7 +148,7 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport
                 else if (declaration instanceof JetProperty) {
                     JetProperty jetProperty = (JetProperty) declaration;
                     Name name = jetProperty.getNameAsSafeName();
-                    Collection<VariableDescriptor> properties = packageDescriptor.getMemberScope().getProperties(name, LookupLocation.NO_LOCATION);
+                    Collection<VariableDescriptor> properties = packageDescriptor.getMemberScope().getProperties(name, LookupLocation.NO_LOCATION_FROM_IDE);
                     for (VariableDescriptor descriptor : properties) {
                         ForceResolveUtil.forceResolveAllContents(descriptor);
                     }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.idea.caches.resolve
 import com.intellij.openapi.project.Project
 import com.intellij.psi.*
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.load.java.structure.impl.*
@@ -73,7 +74,7 @@ fun PsiMember.getJavaMemberDescriptor(): DeclarationDescriptor? {
 }
 
 public fun JavaDescriptorResolver.resolveMethod(method: JavaMethod): FunctionDescriptor? {
-    return getContainingScope(method)?.getFunctions(method.getName())?.findByJavaElement(method)
+    return getContainingScope(method)?.getFunctions(method.name, LookupLocation.NO_LOCATION_FROM_IDE)?.findByJavaElement(method)
 }
 
 public fun JavaDescriptorResolver.resolveConstructor(constructor: JavaConstructor): ConstructorDescriptor? {
@@ -81,7 +82,7 @@ public fun JavaDescriptorResolver.resolveConstructor(constructor: JavaConstructo
 }
 
 public fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescriptor? {
-    return getContainingScope(field)?.getProperties(field.getName())?.findByJavaElement(field) as? PropertyDescriptor
+    return getContainingScope(field)?.getProperties(field.name, LookupLocation.NO_LOCATION_FROM_IDE)?.findByJavaElement(field) as? PropertyDescriptor
 }
 
 private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): JetScope? {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt

@@ -16,11 +16,9 @@
 
 package org.jetbrains.kotlin.idea.util
 
-import com.intellij.openapi.util.Key
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiRecursiveElementVisitor
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.analyzer.analyzeInContext
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -32,10 +30,10 @@ import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.imports.canBeReferencedViaImport
 import org.jetbrains.kotlin.idea.imports.getImportableTargets
 import org.jetbrains.kotlin.idea.util.ShortenReferences.Options
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
-import org.jetbrains.kotlin.psi.psiUtil.isAncestor
 import org.jetbrains.kotlin.psi.psiUtil.parents
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -275,7 +273,7 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
             val typeReference = type.getStrictParentOfType<JetTypeReference>()!!
             val scope = bindingContext[BindingContext.TYPE_RESOLUTION_SCOPE, typeReference]!!
             val name = target.getName()
-            val targetByName = if (target is ClassifierDescriptor) scope.getClassifier(name) else scope.getPackage(name)
+            val targetByName = if (target is ClassifierDescriptor) scope.getClassifier(name, LookupLocation.NO_LOCATION_FROM_IDE) else scope.getPackage(name)
             val canShortenNow = targetByName?.asString() == target.asString()
 
             processQualifiedElement(type, target, canShortenNow)

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/MultipleArgumentsItemProvider.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.idea.JetDescriptorIconProvider
 import org.jetbrains.kotlin.idea.completion.*
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.psi.JetExpression
 import org.jetbrains.kotlin.renderer.render
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -89,7 +90,7 @@ class MultipleArgumentsItemProvider(val bindingContext: BindingContext,
     private fun variableInScope(parameter: ValueParameterDescriptor, scope: JetScope): VariableDescriptor? {
         val name = parameter.getName()
         //TODO: there can be more than one property with such name in scope and we should be able to select one (but we need API for this)
-        val variable = scope.getLocalVariable(name) ?: scope.getProperties(name).singleOrNull() ?: return null
+        val variable = scope.getLocalVariable(name) ?: scope.getProperties(name, LookupLocation.NO_LOCATION_FROM_IDE).singleOrNull() ?: return null
         return if (smartCastCalculator.types(variable).any { JetTypeChecker.DEFAULT.isSubtypeOf(it, parameter.getType()) })
             variable
         else

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.idea.completion.handlers.KotlinFunctionInsertHandler
 import org.jetbrains.kotlin.idea.core.overrideImplement.ImplementMethodsHandler
 import org.jetbrains.kotlin.idea.core.psiClassToDescriptor
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.psi.JetClassOrObject
@@ -253,7 +254,7 @@ class TypeInstantiationItems(
                 is ClassDescriptor -> container.getStaticScope()
                 else -> return
             }
-            val samConstructor = scope.getFunctions(`class`.getName())
+            val samConstructor = scope.getFunctions(`class`.name, LookupLocation.NO_LOCATION_FROM_IDE)
                                          .filterIsInstance<SamConstructorDescriptor>()
                                          .singleOrNull() ?: return
             val lookupElement = lookupElementFactory.createLookupElement(samConstructor, bindingContext, false)

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypesWithContainsDetector.kt

@@ -16,21 +16,21 @@
 
 package org.jetbrains.kotlin.idea.completion.smart
 
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import java.util.HashMap
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.typeUtil.nullability
-import org.jetbrains.kotlin.types.typeUtil.TypeNullability
-import org.jetbrains.kotlin.idea.util.FuzzyType
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.idea.completion.HeuristicSignatures
+import org.jetbrains.kotlin.idea.util.FuzzyType
 import org.jetbrains.kotlin.idea.util.nullability
+import org.jetbrains.kotlin.incremental.components.LookupLocation
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.typeUtil.TypeNullability
+import java.util.HashMap
 
 class TypesWithContainsDetector(
         private val scope: JetScope,
@@ -43,7 +43,7 @@ class TypesWithContainsDetector(
     private val containsName = Name.identifier("contains")
     private val booleanType = KotlinBuiltIns.getInstance().getBooleanType()
 
-    private val typesWithExtensionContains: Collection<JetType> = scope.getFunctions(containsName)
+    private val typesWithExtensionContains: Collection<JetType> = scope.getFunctions(containsName, LookupLocation.NO_LOCATION_FROM_IDE)
             .filter { it.getExtensionReceiverParameter() != null && isGoodContainsFunction(it, listOf()) }
             .map { it.getExtensionReceiverParameter()!!.getType() }
 
@@ -52,7 +52,8 @@ class TypesWithContainsDetector(
     }
 
     private fun hasContainsNoCache(type: FuzzyType): Boolean {
-        return type.nullability() != TypeNullability.NULLABLE && type.type.getMemberScope().getFunctions(containsName).any { isGoodContainsFunction(it, type.freeParameters) }
+        return type.nullability() != TypeNullability.NULLABLE &&
+               type.type.memberScope.getFunctions(containsName, LookupLocation.NO_LOCATION_FROM_IDE).any { isGoodContainsFunction(it, type.freeParameters) }
                || typesWithExtensionContains.any { type.checkIsSubtypeOf(it) != null }
     }
 

idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt

@@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.frontend.di.createContainerForMacros
 import org.jetbrains.kotlin.idea.util.FuzzyType
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.JetPsiFactory
 import org.jetbrains.kotlin.resolve.BindingTraceContext
@@ -41,7 +42,7 @@ public class IterableTypesDetector(
     private val cache = HashMap<FuzzyType, FuzzyType?>()
     private val iteratorName = Name.identifier("iterator")
 
-    private val typesWithExtensionIterator: Collection<JetType> = scope.getFunctions(iteratorName)
+    private val typesWithExtensionIterator: Collection<JetType> = scope.getFunctions(iteratorName, LookupLocation.NO_LOCATION_FROM_IDE)
             .map { it.getExtensionReceiverParameter() }
             .filterNotNull()
             .map { it.getType() }
@@ -74,6 +75,7 @@ public class IterableTypesDetector(
     }
 
     private fun canBeIterable(type: FuzzyType): Boolean {
-        return type.type.getMemberScope().getFunctions(iteratorName).isNotEmpty() || typesWithExtensionIterator.any { type.checkIsSubtypeOf(it) != null }
+        return type.type.memberScope.getFunctions(iteratorName, LookupLocation.NO_LOCATION_FROM_IDE).isNotEmpty() ||
+               typesWithExtensionIterator.any { type.checkIsSubtypeOf(it) != null }
     }
-}
+}

idea/idea-core/src/org/jetbrains/kotlin/idea/core/NameValidators.kt

@@ -21,13 +21,13 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
 import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import org.jetbrains.kotlin.psi.psiUtil.siblings
-import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.JetScope
@@ -96,8 +96,12 @@ public class NewDeclarationNameValidator(
         }
 
         return when(target) {
-            Target.VARIABLES -> getProperties(name).any { !it.isExtension && it.isVisible() } || getLocalVariable(name) != null
-            Target.FUNCTIONS_AND_CLASSES -> getFunctions(name).any { !it.isExtension && it.isVisible() } || getClassifier(name)?.let { it.isVisible() } ?: false
+            Target.VARIABLES ->
+                getProperties(name, LookupLocation.NO_LOCATION_FROM_IDE).any { !it.isExtension && it.isVisible() } ||
+                getLocalVariable(name) != null
+            Target.FUNCTIONS_AND_CLASSES ->
+                getFunctions(name, LookupLocation.NO_LOCATION_FROM_IDE).any { !it.isExtension && it.isVisible() } ||
+                getClassifier(name, LookupLocation.NO_LOCATION_FROM_IDE)?.let { it.isVisible() } ?: false
         }
     }
 

idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt

@@ -42,9 +42,13 @@ import org.jetbrains.kotlin.idea.conversion.copy.range
 import org.jetbrains.kotlin.idea.conversion.copy.start
 import org.jetbrains.kotlin.idea.imports.canBeReferencedViaImport
 import org.jetbrains.kotlin.idea.imports.importableFqName
-import org.jetbrains.kotlin.idea.references.*
+import org.jetbrains.kotlin.idea.references.JetMultiReference
+import org.jetbrains.kotlin.idea.references.JetReference
+import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
@@ -234,10 +238,12 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         val originalFqName = FqName(refData.fqName)
 
         if (refData.kind == KotlinReferenceData.Kind.EXTENSION_FUNCTION) {
-            if (fileResolutionScope.getFunctions(originalFqName.shortName()).any { it.importableFqName == originalFqName }) return null // already imported
+            val functions = fileResolutionScope.getFunctions(originalFqName.shortName(), LookupLocation.NO_LOCATION_FROM_IDE)
+            if (functions.any { it.importableFqName == originalFqName }) return null // already imported
         }
         else if (refData.kind == KotlinReferenceData.Kind.EXTENSION_PROPERTY) {
-            if (fileResolutionScope.getProperties(originalFqName.shortName()).any { it.importableFqName == originalFqName }) return null // already imported
+            val properties = fileResolutionScope.getProperties(originalFqName.shortName(), LookupLocation.NO_LOCATION_FROM_IDE)
+            if (properties.any { it.importableFqName == originalFqName }) return null // already imported
         }
 
         val referencedDescriptors = try {

idea/src/org/jetbrains/kotlin/idea/debugger/PositionManagerLibraryClassFileSearcher.kt

@@ -16,30 +16,28 @@
 
 package org.jetbrains.kotlin.idea.debugger
 
-import com.intellij.psi.search.FilenameIndex
-import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
-import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import com.intellij.openapi.diagnostic.Logger
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import com.intellij.openapi.roots.libraries.LibraryUtil
-import com.intellij.openapi.module.impl.scopes.LibraryScope
-import com.intellij.openapi.roots.LibraryOrderEntry
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.openapi.module.impl.scopes.JdkScope
+import com.intellij.openapi.module.impl.scopes.LibraryScope
 import com.intellij.openapi.roots.JdkOrderEntry
-import org.jetbrains.kotlin.psi.JetPsiUtil
-import org.jetbrains.kotlin.resolve.jvm.JvmClassName
-import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import com.intellij.openapi.roots.LibraryOrderEntry
+import com.intellij.openapi.roots.libraries.LibraryUtil
+import com.intellij.psi.search.FilenameIndex
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import com.intellij.util.indexing.FileBasedIndex
+import org.jetbrains.kotlin.incremental.components.LookupLocation
+import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
+import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.JetElement
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
+import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor
+import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
 
 private val LOG = Logger.getInstance("org.jetbrains.kotlin.idea.debugger")
 
@@ -64,8 +62,8 @@ fun findPackagePartInternalNameForLibraryFile(topLevelDeclaration: JetDeclaratio
     val descFromSourceText = render(descriptor)
 
     val descriptors: Collection<CallableDescriptor> = when (descriptor) {
-        is FunctionDescriptor -> packageDescriptor.memberScope.getFunctions(descriptor.getName())
-        is PropertyDescriptor -> packageDescriptor.memberScope.getProperties(descriptor.getName())
+        is FunctionDescriptor -> packageDescriptor.memberScope.getFunctions(descriptor.name, LookupLocation.NO_LOCATION_FROM_IDE)
+        is PropertyDescriptor -> packageDescriptor.memberScope.getProperties(descriptor.name, LookupLocation.NO_LOCATION_FROM_IDE)
         else -> {
             reportError(topLevelDeclaration, descriptor)
             listOf()

idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.idea.core.formatter.JetCodeStyleSettings
 import org.jetbrains.kotlin.idea.references.JetReference
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -198,7 +199,7 @@ public class KotlinImportOptimizer() : ImportOptimizer {
             val scope = fileWithImports.getResolutionFacade().getFileTopLevelScope(fileWithImports)
 
             for (fqName in classNamesToCheck) {
-                if (scope.getClassifier(fqName.shortName())?.importableFqNameSafe != fqName) {
+                if (scope.getClassifier(fqName.shortName(), LookupLocation.NO_LOCATION_FROM_IDE)?.importableFqNameSafe != fqName) {
                     // add explicit import if failed to import with * (or from current package)
                     importsToGenerate.add(ImportPath(fqName, false))
 

idea/src/org/jetbrains/kotlin/idea/intentions/ConvertFunctionToPropertyIntention.kt

@@ -42,14 +42,15 @@ import org.jetbrains.kotlin.idea.search.usagesSearch.search
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.types.typeUtil.supertypes
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
+import org.jetbrains.kotlin.types.typeUtil.supertypes
 import java.util.ArrayList
 
 public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetNamedFunction>(javaClass(), "Convert function to property"), LowPriorityAction {
@@ -114,7 +115,7 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
                     }
 
                     callableDescriptor.getContainingScope(bindingContext)
-                            ?.getProperties(callableDescriptor.getName())
+                            ?.getProperties(callableDescriptor.name, LookupLocation.NO_LOCATION_FROM_IDE)
                             ?.firstOrNull()
                             ?.let { DescriptorToSourceUtilsIde.getAnyDeclaration(project, it) }
                             ?.let { reportDeclarationConflict(conflicts, it) { "$it already exists" } }

idea/src/org/jetbrains/kotlin/idea/intentions/ConvertPropertyToFunctionIntention.kt

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.idea.search.usagesSearch.DefaultSearchHelper
 import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchTarget
 import org.jetbrains.kotlin.idea.search.usagesSearch.search
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
@@ -96,7 +97,7 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
 
                 if (callable is JetProperty) {
                     callableDescriptor.getContainingScope(bindingContext)
-                            ?.getFunctions(callableDescriptor.getName())
+                            ?.getFunctions(callableDescriptor.name, LookupLocation.NO_LOCATION_FROM_IDE)
                             ?.firstOrNull { it.getValueParameters().isEmpty() }
                             ?.let { DescriptorToSourceUtilsIde.getAnyDeclaration(project, it) }
                             ?.let { reportDeclarationConflict(conflicts, it) { "$it already exists" } }

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeMemberFunctionSignatureFix.java

@@ -268,7 +268,7 @@ public class ChangeMemberFunctionSignatureFix extends JetHintAction<JetNamedFunc
         Name name = functionDescriptor.getName();
         for (JetType type : TypeUtils.getAllSupertypes(classDescriptor.getDefaultType())) {
             JetScope scope = type.getMemberScope();
-            for (FunctionDescriptor function : scope.getFunctions(name, LookupLocation.NO_LOCATION)) {
+            for (FunctionDescriptor function : scope.getFunctions(name, LookupLocation.NO_LOCATION_FROM_IDE)) {
                 if (!function.getKind().isReal()) continue;
                 if (function.getModality().isOverridable())
                     superFunctions.add(function);

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt

@@ -54,6 +54,7 @@ import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.name.FqName
@@ -399,7 +400,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                     SourceElement.NO_SOURCE
             )
 
-            val validator = CollectingNameValidator { scope.getClassifier(Name.identifier(it)) == null }
+            val validator = CollectingNameValidator { scope.getClassifier(Name.identifier(it), LookupLocation.NO_LOCATION_FROM_IDE) == null }
             val parameterNames = KotlinNameSuggester.suggestNamesForTypeParameters(typeParameterCount, validator)
             val typeParameters = (0..typeParameterCount - 1).map {
                 TypeParameterDescriptorImpl.createWithDefaultBound(
@@ -619,7 +620,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 }
             }
 
-            val validator = CollectingNameValidator { scope.getClassifier(Name.identifier(it)) == null }
+            val validator = CollectingNameValidator { scope.getClassifier(Name.identifier(it), LookupLocation.NO_LOCATION_FROM_IDE) == null }
             val typeParameterNames = allTypeParametersNotInScope.map { KotlinNameSuggester.suggestNameByName(it.getName().asString(), validator) }
 
             return allTypeParametersNotInScope.zip(typeParameterNames).toMap()

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
@@ -65,7 +66,7 @@ private fun JetType.renderLong(typeParameterNameMap: Map<TypeParameterDescriptor
 
 private fun getTypeParameterNamesNotInScope(typeParameters: Collection<TypeParameterDescriptor>, scope: JetScope): List<TypeParameterDescriptor> {
     return typeParameters.filter { typeParameter ->
-        val classifier = scope.getClassifier(typeParameter.getName())
+        val classifier = scope.getClassifier(typeParameter.name, LookupLocation.NO_LOCATION_FROM_IDE)
         classifier == null || classifier != typeParameter
     }
 }

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.getTyp
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.guessTypes
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAssignmentByLHS
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElement
@@ -136,5 +137,5 @@ fun JetType.hasTypeParametersToAdd(functionDescriptor: FunctionDescriptor, conte
                 else -> null
             } ?: return true
 
-    return typeParametersToAdd.any { scope.getClassifier(it.name) != it }
+    return typeParametersToAdd.any { scope.getClassifier(it.name, LookupLocation.NO_LOCATION_FROM_IDE) != it }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.CollectingNameValidator
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.JetCallableDeclaration
 import org.jetbrains.kotlin.psi.JetClass
@@ -80,7 +81,7 @@ public class JetChangeSignatureData(
         val validator = bodyScope?.let { bodyScope ->
             CollectingNameValidator(paramNames) {
                 val name = Name.identifier(it)
-                bodyScope.getLocalVariable(name) == null && bodyScope.getProperties(name).isEmpty()
+                bodyScope.getLocalVariable(name) == null && bodyScope.getProperties(name, LookupLocation.NO_LOCATION_FROM_IDE).isEmpty()
             }
         } ?: CollectingNameValidator(paramNames)
         val receiverType = baseDescriptor.getExtensionReceiverParameter()?.getType() ?: return null

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java

@@ -623,8 +623,8 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
         if (!kind.getIsConstructor() && callableScope != null && !info.getNewName().isEmpty()) {
             Name newName = Name.identifier(info.getNewName());
             Collection<? extends CallableDescriptor> conflicts = oldDescriptor instanceof FunctionDescriptor
-                                                                 ? callableScope.getFunctions(newName, LookupLocation.NO_LOCATION)
-                                                                 : callableScope.getProperties(newName, LookupLocation.NO_LOCATION);
+                                                                 ? callableScope.getFunctions(newName, LookupLocation.NO_LOCATION_FROM_IDE)
+                                                                 : callableScope.getProperties(newName, LookupLocation.NO_LOCATION_FROM_IDE);
             for (CallableDescriptor conflict : conflicts) {
                 if (conflict == oldDescriptor) continue;
 
@@ -647,7 +647,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
             }
             if (parametersScope != null) {
                 if (kind == JetMethodDescriptor.Kind.PRIMARY_CONSTRUCTOR && valOrVar != JetValVar.None) {
-                    for (VariableDescriptor property : parametersScope.getProperties(Name.identifier(parameterName), LookupLocation.NO_LOCATION)) {
+                    for (VariableDescriptor property : parametersScope.getProperties(Name.identifier(parameterName), LookupLocation.NO_LOCATION_FROM_IDE)) {
                         PsiElement propertyDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(property);
 
                         if (propertyDeclaration != null && !(propertyDeclaration.getParent() instanceof JetParameterList)) {

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt

@@ -60,6 +60,7 @@ import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.approximateWithResolvableType
 import org.jetbrains.kotlin.idea.util.isResolvableInScope
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
@@ -649,7 +650,7 @@ private fun ExtractionData.inferParametersInfo(
                     options.captureLocalFunctions
                     && originalRef.getReferencedName() == originalDescriptor.getName().asString() // to forbid calls by convention
                     && originalDeclaration is JetNamedFunction && originalDeclaration.isLocal()
-                    && (targetScope == null || originalDescriptor !in targetScope.getFunctions(originalDescriptor.getName()))
+                    && (targetScope == null || originalDescriptor !in targetScope.getFunctions(originalDescriptor.name, LookupLocation.NO_LOCATION_FROM_IDE))
 
             val descriptorToExtract = (if (extractThis) thisDescriptor else null) ?: originalDescriptor
 
@@ -1024,4 +1025,4 @@ fun ExtractableCodeDescriptor.validate(): ExtractableCodeDescriptorWithConflicts
     return ExtractableCodeDescriptorWithConflicts(this, conflicts)
 }
 
-private val LOG = Logger.getInstance(javaClass<ExtractionEngine>())
+private val LOG = Logger.getInstance(javaClass<ExtractionEngine>())

idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.kotlin.util
 
-import com.intellij.codeInsight.CodeInsightSettings
-import com.intellij.codeInsight.actions.OptimizeImportsProcessor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.impl.PsiModificationTrackerImpl
@@ -33,6 +31,7 @@ import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
 import org.jetbrains.kotlin.idea.refactoring.fqName.isImported
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper.ImportDescriptorResult
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
@@ -121,11 +120,24 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
 
             // check if import is not needed
             when (target) {
-                is ClassDescriptor -> { if (topLevelScope.getClassifier(name)?.importableFqName == targetFqName) return ImportDescriptorResult.ALREADY_IMPORTED }
-                is PackageViewDescriptor -> { if (topLevelScope.getPackage(name)?.importableFqName == targetFqName) return ImportDescriptorResult.ALREADY_IMPORTED }
-                is FunctionDescriptor -> { if (topLevelScope.getFunctions(name).map { it.importableFqName }.contains(targetFqName)) return ImportDescriptorResult.ALREADY_IMPORTED }
-                is PropertyDescriptor -> { if (topLevelScope.getProperties(name).map { it.importableFqName }.contains(targetFqName)) return ImportDescriptorResult.ALREADY_IMPORTED }
-                else -> return ImportDescriptorResult.FAIL
+                is ClassDescriptor -> {
+                    val classifier = topLevelScope.getClassifier(name, LookupLocation.NO_LOCATION_FROM_IDE)
+                    if (classifier?.importableFqName == targetFqName) return ImportDescriptorResult.ALREADY_IMPORTED
+                }
+                is PackageViewDescriptor -> {
+                    if (topLevelScope.getPackage(name)?.importableFqName == targetFqName) return ImportDescriptorResult.ALREADY_IMPORTED
+                }
+                is FunctionDescriptor -> {
+                    val functions = topLevelScope.getFunctions(name, LookupLocation.NO_LOCATION_FROM_IDE)
+                    if (functions.map { it.importableFqName }.contains(targetFqName)) return ImportDescriptorResult.ALREADY_IMPORTED
+                }
+                is PropertyDescriptor -> {
+                    val properties = topLevelScope.getProperties(name, LookupLocation.NO_LOCATION_FROM_IDE)
+                    if (properties.map { it.importableFqName }.contains(targetFqName)) return ImportDescriptorResult.ALREADY_IMPORTED
+                }
+                else -> {
+                    return ImportDescriptorResult.FAIL
+                }
             }
 
             if (!mayImportByCodeStyle(descriptor)) {
@@ -139,7 +151,7 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
 
             // check there is an explicit import of a class/package with the same name already
             val conflict = when (target) {
-                is ClassDescriptor -> topLevelScope.getClassifier(name)
+                is ClassDescriptor -> topLevelScope.getClassifier(name, LookupLocation.NO_LOCATION_FROM_IDE)
                 is PackageViewDescriptor -> topLevelScope.getPackage(name)
                 else -> null
             }
@@ -156,7 +168,9 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
 
             val tryStarImport = shouldTryStarImport(packageFqName, imports)
                                     && when (target) {
-                                        is ClassDescriptor -> topLevelScope.getClassifier(name) == null // this check does not give a guarantee that import with * will import the class - for example, there can be classes with conflicting name in more than one import with *
+                                        // this check does not give a guarantee that import with * will import the class - for example,
+                                        // there can be classes with conflicting name in more than one import with *
+                                        is ClassDescriptor -> topLevelScope.getClassifier(name, LookupLocation.NO_LOCATION_FROM_IDE) == null
                                         is PackageViewDescriptor -> false
                                         is FunctionDescriptor, is PropertyDescriptor -> true
                                         else -> throw Exception()
@@ -222,12 +236,14 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
             val topLevelScope = resolutionFacade.getFileTopLevelScope(file)
             val conflictCandidates: List<ClassifierDescriptor> = classNamesToImport
                     .flatMap {
-                        importedScopes.map { scope -> scope.getClassifier(it) }.filterNotNull()
+                        importedScopes.map { scope -> scope.getClassifier(it, LookupLocation.NO_LOCATION_FROM_IDE) }.filterNotNull()
                     }
                     .filter { importedClass ->
                         isVisible(importedClass)
-                            && topLevelScope.getClassifier(importedClass.getName()) == importedClass /* check that class is really imported */
-                            && imports.all { it.getImportPath() != ImportPath(importedClass.importableFqNameSafe, false)  } /* and not yet imported explicitly */
+                            // check that class is really imported
+                            && topLevelScope.getClassifier(importedClass.name, LookupLocation.NO_LOCATION_FROM_IDE) == importedClass
+                            // and not yet imported explicitly
+                            && imports.all { it.importPath != ImportPath(importedClass.importableFqNameSafe, false)  }
                     }
             val conflicts = detectNeededImports(conflictCandidates)
 
@@ -235,7 +251,7 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
 
             if (target is ClassDescriptor) {
                 val newTopLevelScope = resolutionFacade.getFileTopLevelScope(file)
-                val resolvedTo = newTopLevelScope.getClassifier(target.getName())
+                val resolvedTo = newTopLevelScope.getClassifier(target.name, LookupLocation.NO_LOCATION_FROM_IDE)
                 if (resolvedTo?.importableFqNameSafe != targetFqName) {
                     addedImport.delete()
                     return ImportDescriptorResult.FAIL
@@ -258,7 +274,8 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
             }
 
             val parentScope = getMemberScope(fqName.parent(), moduleDescriptor) ?: return null
-            val classDescriptor = parentScope.getClassifier(fqName.shortName()) as? ClassDescriptor ?: return null
+            val classifier = parentScope.getClassifier(fqName.shortName(), LookupLocation.NO_LOCATION_FROM_IDE)
+            val classDescriptor = classifier as? ClassDescriptor ?: return null
             return classDescriptor.getDefaultType().getMemberScope()
         }
 
@@ -269,7 +286,7 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
 
                 // check if there is a conflicting class imported with * import
                 // (not with explicit import - explicit imports are checked before this method invocation)
-                val classifier = topLevelScope.getClassifier(name)
+                val classifier = topLevelScope.getClassifier(name, LookupLocation.NO_LOCATION_FROM_IDE)
                 if (classifier != null && detectNeededImports(listOf(classifier)).isNotEmpty()) {
                     return ImportDescriptorResult.FAIL
                 }
@@ -298,7 +315,8 @@ public class ImportInsertHelperImpl(private val project: Project) : ImportInsert
             if (importsToCheck.isNotEmpty()) {
                 val topLevelScope = resolutionFacade.getFileTopLevelScope(file)
                 for (classFqName in importsToCheck) {
-                    if (topLevelScope.getClassifier(classFqName.shortName())?.importableFqNameSafe != classFqName) {
+                    val classifier = topLevelScope.getClassifier(classFqName.shortName(), LookupLocation.NO_LOCATION_FROM_IDE)
+                    if (classifier?.importableFqNameSafe != classFqName) {
                         addImport(classFqName, false) // restore explicit import
                     }
                 }

idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocFinderTest.kt

@@ -18,8 +18,9 @@ package org.jetbrains.kotlin.idea.kdoc
 
 import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
+import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.JetFile
 import org.junit.Assert
@@ -42,7 +43,7 @@ public class KDocFinderTest() : LightPlatformCodeInsightFixtureTestCase() {
         myFixture.configureByFile(getTestName(false) + ".kt")
         val declaration = (myFixture.getFile() as JetFile).getDeclarations().single { it.getName() == "Bar" }
         val descriptor = declaration.resolveToDescriptor() as ClassDescriptor
-        val overriddenFunctionDescriptor = descriptor.getDefaultType().getMemberScope().getFunctions(Name.identifier("xyzzy")).single()
+        val overriddenFunctionDescriptor = descriptor.defaultType.memberScope.getFunctions(Name.identifier("xyzzy"), LookupLocation.NO_LOCATION_FROM_TEST).single()
         val doc = KDocFinder.findKDoc(overriddenFunctionDescriptor)
         Assert.assertEquals("Doc for method xyzzy", doc!!.getContent())
     }
@@ -51,7 +52,7 @@ public class KDocFinderTest() : LightPlatformCodeInsightFixtureTestCase() {
         myFixture.configureByFile(getTestName(false) + ".kt")
         val declaration = (myFixture.getFile() as JetFile).getDeclarations().single { it.getName() == "Bar" }
         val descriptor = declaration.resolveToDescriptor() as ClassDescriptor
-        val overriddenFunctionDescriptor = descriptor.getDefaultType().getMemberScope().getFunctions(Name.identifier("xyzzy")).single()
+        val overriddenFunctionDescriptor = descriptor.defaultType.memberScope.getFunctions(Name.identifier("xyzzy"), LookupLocation.NO_LOCATION_FROM_TEST).single()
         val doc = KDocFinder.findKDoc(overriddenFunctionDescriptor)
         Assert.assertEquals("Doc for method xyzzy", doc!!.getContent())
     }
@@ -60,7 +61,7 @@ public class KDocFinderTest() : LightPlatformCodeInsightFixtureTestCase() {
         myFixture.configureByFile(getTestName(false) + ".kt")
         val declaration = (myFixture.getFile() as JetFile).getDeclarations().single { it.getName() == "Foo" }
         val descriptor = declaration.resolveToDescriptor() as ClassDescriptor
-        val propertyDescriptor = descriptor.getDefaultType().getMemberScope().getProperties(Name.identifier("xyzzy")).single()
+        val propertyDescriptor = descriptor.defaultType.memberScope.getProperties(Name.identifier("xyzzy"), LookupLocation.NO_LOCATION_FROM_TEST).single()
         val doc = KDocFinder.findKDoc(propertyDescriptor)
         Assert.assertEquals("Doc for property xyzzy", doc!!.getContent())
     }

idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/AbstractRenameTest.kt

@@ -47,6 +47,7 @@ import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils
 import org.jetbrains.kotlin.idea.test.KotlinMultiFileTestCase
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.*
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
@@ -185,13 +186,13 @@ public abstract class AbstractRenameTest : KotlinMultiFileTestCase() {
     private fun renameKotlinFunctionTest(renameParamsObject: JsonObject, context: TestContext) {
         val oldMethodName = Name.identifier(renameParamsObject.getString("oldName"))
 
-        doRenameInKotlinClassOrPackage(renameParamsObject, context) { it.getFunctions(oldMethodName).first() }
+        doRenameInKotlinClassOrPackage(renameParamsObject, context) { it.getFunctions(oldMethodName, LookupLocation.NO_LOCATION_FROM_TEST).first() }
     }
 
     private fun renameKotlinPropertyTest(renameParamsObject: JsonObject, context: TestContext) {
         val oldPropertyName = Name.identifier(renameParamsObject.getString("oldName"))
 
-        doRenameInKotlinClassOrPackage(renameParamsObject, context) { it.getProperties(oldPropertyName).first() }
+        doRenameInKotlinClassOrPackage(renameParamsObject, context) { it.getProperties(oldPropertyName, LookupLocation.NO_LOCATION_FROM_TEST).first() }
     }
 
     private fun renameKotlinClassTest(renameParamsObject: JsonObject, context: TestContext) {