Move: Fix processing of calls and callable references

Fix CCE on callable references to Java methods. Fix qualification of callable references without receivers. Fix processing of calls/callable references to object extensions and extension members. Do not explicate short companion references #KT-16809 Fixed
2017-03-22 16:08:47 +03:00
parent 58495555dc
commit 1d0162402e
52 changed files with 1577 additions and 42 deletions
@@ -66,6 +66,13 @@ fun KtSimpleNameExpression.getQualifiedElement(): KtElement {
    }
 }

+fun KtSimpleNameExpression.getQualifiedElementOrCallableRef(): KtElement {
+    val parent = parent
+    if (parent is KtCallableReferenceExpression && parent.callableReference == this) return parent
+
+    return getQualifiedElement()
+}
+
 fun KtSimpleNameExpression.getTopmostParentQualifiedExpressionForSelector(): KtQualifiedExpression? {
    return generateSequence<KtExpression>(this) {
        val parentQualified = it.parent as? KtQualifiedExpression
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
 import org.jetbrains.kotlin.idea.codeInsight.shorten.isToBeShortened
 import org.jetbrains.kotlin.idea.core.ShortenReferences
+import org.jetbrains.kotlin.idea.core.copied
 import org.jetbrains.kotlin.idea.core.quoteIfNeeded
 import org.jetbrains.kotlin.idea.intentions.OperatorToFunctionIntention
 import org.jetbrains.kotlin.idea.refactoring.fqName.getKotlinFqName
@@ -37,10 +38,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.isOneSegmentFQN
 import org.jetbrains.kotlin.plugin.references.SimpleNameReferenceExtension
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch
-import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElement
-import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector
-import org.jetbrains.kotlin.psi.psiUtil.startOffset
+import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
@@ -152,7 +150,7 @@ class KtSimpleNameReference(expression: KtSimpleNameExpression) : KtSimpleRefere
        if (expression.parent is KtThisExpression || expression.parent is KtSuperExpression) return expression // TODO: it's a bad design of PSI tree, we should change it

        val newExpression = expression.changeQualifiedName(fqName.quoteIfNeeded())
-        val newQualifiedElement = newExpression.getQualifiedElement()
+        val newQualifiedElement = newExpression.getQualifiedElementOrCallableRef()

        if (shorteningMode == ShorteningMode.NO_SHORTENING) return newExpression

@@ -179,14 +177,24 @@ class KtSimpleNameReference(expression: KtSimpleNameExpression) : KtSimpleRefere

        val shortName = fqName.shortName().asString()
        val psiFactory = KtPsiFactory(this)
-        val fqNameBase = (parent as? KtCallExpression)?.let { parent ->
-            val callCopy = parent.copy() as KtCallExpression
-            callCopy.calleeExpression!!.replace(psiFactory.createSimpleName(shortName)).parent!!.text
-        } ?: shortName
+        val parent = parent
+        var parentDelimiter = "."
+        val fqNameBase = when {
+            parent is KtCallElement -> {
+                val callCopy = parent.copied()
+                callCopy.calleeExpression!!.replace(psiFactory.createSimpleName(shortName)).parent!!.text
+            }
+            parent is KtCallableReferenceExpression && parent.callableReference == this -> {
+                parentDelimiter = ""
+                val callableRefCopy = parent.copied()
+                callableRefCopy.callableReference.replace(psiFactory.createSimpleName(shortName)).parent!!.text
+            }
+            else -> shortName
+        }

-        val text = if (!fqName.isOneSegmentFQN()) "${fqName.parent().asString()}.$fqNameBase" else fqNameBase
+        val text = if (!fqName.isOneSegmentFQN()) "${fqName.parent().asString()}$parentDelimiter$fqNameBase" else fqNameBase

-        val elementToReplace = getQualifiedElement()
+        val elementToReplace = getQualifiedElementOrCallableRef()

        val newElement = when (elementToReplace) {
            is KtUserType -> {
@@ -196,7 +204,9 @@ class KtSimpleNameReference(expression: KtSimpleNameExpression) : KtSimpleRefere
            else -> elementToReplace.replace(psiFactory.createExpression(text))
        } as KtElement

-        val selector = newElement.getQualifiedElementSelector() ?: error("No selector for $newElement")
+        val selector = (newElement as? KtCallableReferenceExpression)?.callableReference
+                       ?: newElement.getQualifiedElementSelector()
+                       ?: error("No selector for $newElement")
        return selector as KtNameReferenceExpression
    }

@@ -38,7 +38,6 @@ import com.intellij.util.IncorrectOperationException
 import com.intellij.util.SmartList
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.asJava.namedUnwrappedElement
-import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
@@ -50,11 +49,9 @@ import org.jetbrains.kotlin.idea.imports.importableFqName
 import org.jetbrains.kotlin.idea.refactoring.fqName.isImported
 import org.jetbrains.kotlin.idea.refactoring.isInJavaSourceRoot
 import org.jetbrains.kotlin.idea.refactoring.move.moveDeclarations.ui.KotlinAwareMoveFilesOrDirectoriesDialog
-import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.references.KtSimpleNameReference.ShorteningMode
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.idea.util.application.executeCommand
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
@@ -139,30 +136,31 @@ fun KtElement.lazilyProcessInternalReferencesToUpdateOnPackageNameChange(
        val isExtension = isCallable && declaration.isExtensionDeclaration()
        val isCallableReference = isCallableReference(refExpr.mainReference)

-        if (isCallable && !isCallableReference) {
-            if (isExtension && containingDescriptor is ClassDescriptor) {
-                val implicitClass = (refExpr.getResolvedCall(bindingContext)?.dispatchReceiver as? ImplicitClassReceiver)?.classDescriptor
-                if (DescriptorUtils.isCompanionObject(implicitClass)) {
-                    return ::ImplicitCompanionAsDispatchReceiverUsageInfo
+        if (isCallable) {
+            if (!isCallableReference) {
+                if (isExtension && containingDescriptor is ClassDescriptor) {
+                    val dispatchReceiver = refExpr.getResolvedCall(bindingContext)?.dispatchReceiver
+                    val implicitClass = (dispatchReceiver as? ImplicitClassReceiver)?.classDescriptor
+                    if (DescriptorUtils.isCompanionObject(implicitClass)) {
+                        return ::ImplicitCompanionAsDispatchReceiverUsageInfo
+                    }
+                    if (dispatchReceiver != null || containingDescriptor.kind != ClassKind.OBJECT) return null
                }
-                return null
            }

            if (!isExtension) {
-                if (refExpr.getReceiverExpression() != null) {
-                    return fun(refExpr: KtSimpleNameExpression): UsageInfo? {
-                        val receiver = refExpr.getReceiverExpression() ?: return null
-                        val receiverRef = receiver.getQualifiedElementSelector() as? KtSimpleNameExpression ?: return null
-                        if (bindingContext[BindingContext.QUALIFIER, receiverRef] == null) return null
-                        return processReference(receiverRef, bindingContext)?.invoke(receiverRef)
-                    }
-                }
                if (!(containingDescriptor is PackageFragmentDescriptor
                      || containingDescriptor is ClassDescriptor && containingDescriptor.kind == ClassKind.OBJECT)) return null
            }
        }

-        val fqName = DescriptorUtils.getFqName(descriptor)
+        val fqName = DescriptorUtils.getFqName(descriptor).let {
+            if (DescriptorUtils.isCompanionObject(descriptor)
+                && bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, refExpr] != null) {
+                it.parent()
+            }
+            else it
+        }
        if (!fqName.isSafe) return null

        val (oldContainer, newContainer) = containerChangeInfo
@@ -182,8 +180,7 @@ fun KtElement.lazilyProcessInternalReferencesToUpdateOnPackageNameChange(
            // Check container instead of declaration itself as the latter may be not real (e.g. fake override)
            if (isAncestor(containingDeclarationForNonRealMember ?: declaration, false)) {
                if (descriptor.importableFqName == null) return null
-                if (isUnqualifiedExtensionReference(refExpr.mainReference, declaration)) return null
-                if (isCallableReference(refExpr.mainReference)) return null
+                if (getReferenceKind(refExpr.mainReference, declaration) != ReferenceKind.QUALIFIABLE) return null
                if (containerFqName == null || newContainer is ContainerInfo.UnknownPackage) return null
                return fqName.asString().let {
                    val prefix = containerFqName.asString()
@@ -202,7 +199,7 @@ fun KtElement.lazilyProcessInternalReferencesToUpdateOnPackageNameChange(
            return createMoveUsageInfoIfPossible(refExpr.mainReference, declaration, false, fqName.toSafe())
        }

-        if (isExtension || isCallableReference || containerFqName != null || isImported(descriptor)) return ::doCreateUsageInfo
+        if (isExtension || containerFqName != null || isImported(descriptor)) return ::doCreateUsageInfo
        return null
    }

@@ -210,7 +207,6 @@ fun KtElement.lazilyProcessInternalReferencesToUpdateOnPackageNameChange(

    for ((refExpr, bindingContext) in referenceToContext) {
        if (refExpr !is KtSimpleNameExpression || refExpr.parent is KtThisExpression) continue
-        if (bindingContext[BindingContext.QUALIFIER, refExpr] != null) continue

        processReference(refExpr, bindingContext)?.let { body(refExpr, it) }
    }
@@ -255,18 +251,35 @@ fun createMoveUsageInfoIfPossible(
    val startOffset = range.startOffset
    val endOffset = range.endOffset

-    if (isUnqualifiedExtensionReference(reference, referencedElement) || isCallableReference(reference)) {
-        return UnqualifiableMoveRenameUsageInfo(
+    return when (getReferenceKind(reference, referencedElement)) {
+        ReferenceKind.QUALIFIABLE -> QualifiableMoveRenameUsageInfo(
+                element, reference, startOffset, endOffset, referencedElement, newFqName
+        )
+        ReferenceKind.UNQUALIFIABLE -> UnqualifiableMoveRenameUsageInfo(
                element, reference, startOffset, endOffset, referencedElement, element.containingFile!!, addImportToOriginalFile
        )
+        else -> null
    }
-    return QualifiableMoveRenameUsageInfo(element, reference, startOffset, endOffset, referencedElement, newFqName)
 }

-private fun isUnqualifiedExtensionReference(reference: PsiReference, referencedElement: PsiElement): Boolean {
-    return reference is KtReference
-           && (referencedElement.namedUnwrappedElement as? KtDeclaration)?.isExtensionDeclaration() ?: false
-           && reference.element.getNonStrictParentOfType<KtImportDirective>() == null
+private enum class ReferenceKind {
+    QUALIFIABLE,
+    UNQUALIFIABLE,
+    IRRELEVANT
+}
+
+private fun getReferenceKind(reference: PsiReference, referencedElement: PsiElement): ReferenceKind {
+    val element = reference.element as? KtSimpleNameExpression ?: return ReferenceKind.QUALIFIABLE
+
+    if ((referencedElement.namedUnwrappedElement as? KtDeclaration)?.isExtensionDeclaration() ?: false
+        && reference.element.getNonStrictParentOfType<KtImportDirective>() == null) return ReferenceKind.UNQUALIFIABLE
+
+    element.getParentOfTypeAndBranch<KtCallableReferenceExpression> { callableReference }?.let {
+        if (it.receiverExpression != null) return ReferenceKind.IRRELEVANT
+        if (referencedElement is KtDeclaration && referencedElement.parent is KtFile) return ReferenceKind.UNQUALIFIABLE
+    }
+
+    return ReferenceKind.QUALIFIABLE
 }

 private fun isCallableReference(reference: PsiReference): Boolean {
@@ -358,7 +371,7 @@ fun postProcessMoveUsages(usages: Collection<UsageInfo>,

            is UnqualifiableMoveRenameUsageInfo -> {
                val file = with(usage) { if (addImportToOriginalFile) originalFile else counterpart(originalFile) } as KtFile
-                val declaration = counterpart(usage.referencedElement!!).unwrapped as KtDeclaration
+                val declaration = counterpart(usage.referencedElement!!)
                addDelayedImportRequest(declaration, file)
            }

@@ -0,0 +1,4 @@
+package bar
+
+class X
+
@@ -0,0 +1,55 @@
+package baz
+
+import foo.O.objectExtensionMember2
+import foo.classExtension
+import foo.companionExtension
+import foo.objectExtension
+
+fun test() {
+    foo.A().classMember()
+    foo.A().classExtension()
+    foo.O.objectMember1()
+    foo.O.objectMember2()
+    foo.O.objectExtension()
+    foo.A.companionMember()
+    foo.A.companionExtension()
+    foo.J().javaClassMember()
+    foo.J.javaClassStaticMember()
+    foo.topLevel()
+    with(foo.O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(foo.A) { 1.companionExtensionMember() }
+
+    foo.A()::classMember
+    foo.A::classMember
+    foo.A()::classExtension
+    foo.A::classExtension
+    foo.O::objectMember1
+    foo.O::objectMember2
+    foo.O::objectExtension
+    foo.A.Companion::companionMember
+    (foo.A)::companionMember
+    foo.A.Companion::companionExtension
+    (foo.A)::companionExtension
+    foo.J()::javaClassMember
+    foo.J::javaClassMember
+    foo.J::javaClassStaticMember
+    //::topLevel // not usable without import
+
+    with(foo.A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(foo.J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,57 @@
+package bar
+
+import foo.O.objectExtensionMember2
+import foo.classExtension
+import foo.companionExtension
+import foo.objectExtension
+
+class X
+
+fun <caret>test() {
+    foo.A().classMember()
+    foo.A().classExtension()
+    foo.O.objectMember1()
+    foo.O.objectMember2()
+    foo.O.objectExtension()
+    foo.A.companionMember()
+    foo.A.companionExtension()
+    foo.J().javaClassMember()
+    foo.J.javaClassStaticMember()
+    foo.topLevel()
+    with(foo.O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(foo.A) { 1.companionExtensionMember() }
+
+    foo.A()::classMember
+    foo.A::classMember
+    foo.A()::classExtension
+    foo.A::classExtension
+    foo.O::objectMember1
+    foo.O::objectMember2
+    foo.O::objectExtension
+    foo.A.Companion::companionMember
+    (foo.A)::companionMember
+    foo.A.Companion::companionExtension
+    (foo.A)::companionExtension
+    foo.J()::javaClassMember
+    foo.J::javaClassMember
+    foo.J::javaClassStaticMember
+    //::topLevel // not usable without import
+
+    with(foo.A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(foo.J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,5 @@
+{
+  "mainFile": "bar/usages.kt",
+  "type": "MOVE_KOTLIN_TOP_LEVEL_DECLARATIONS",
+  "targetPackage": "baz"
+}
@@ -0,0 +1,4 @@
+package bar
+
+class X
+
@@ -0,0 +1,59 @@
+package baz
+
+import foo.A
+import foo.J
+import foo.O
+import foo.O.objectExtensionMember2
+import foo.classExtension
+import foo.companionExtension
+import foo.objectExtension
+import foo.topLevel
+
+fun test() {
+    A().classMember()
+    A().classExtension()
+    O.objectMember1()
+    O.objectMember2()
+    O.objectExtension()
+    A.companionMember()
+    A.companionExtension()
+    J().javaClassMember()
+    J.javaClassStaticMember()
+    topLevel()
+    with(O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(A) { 1.companionExtensionMember() }
+
+    A()::classMember
+    A::classMember
+    A()::classExtension
+    A::classExtension
+    O::objectMember1
+    O::objectMember2
+    O::objectExtension
+    A.Companion::companionMember
+    (A)::companionMember
+    A.Companion::companionExtension
+    (A)::companionExtension
+    J()::javaClassMember
+    J::javaClassMember
+    J::javaClassStaticMember
+    ::topLevel
+
+    with(A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,56 @@
+package bar
+
+import foo.*
+import foo.O.objectMember2
+import foo.O.objectExtensionMember2
+
+class X
+
+fun <caret>test() {
+    A().classMember()
+    A().classExtension()
+    O.objectMember1()
+    objectMember2()
+    O.objectExtension()
+    A.companionMember()
+    A.companionExtension()
+    J().javaClassMember()
+    J.javaClassStaticMember()
+    topLevel()
+    with(O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(A) { 1.companionExtensionMember() }
+
+    A()::classMember
+    A::classMember
+    A()::classExtension
+    A::classExtension
+    O::objectMember1
+    ::objectMember2
+    O::objectExtension
+    A.Companion::companionMember
+    (A)::companionMember
+    A.Companion::companionExtension
+    (A)::companionExtension
+    J()::javaClassMember
+    J::javaClassMember
+    J::javaClassStaticMember
+    ::topLevel
+
+    with(A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,5 @@
+{
+  "mainFile": "bar/usages.kt",
+  "type": "MOVE_KOTLIN_TOP_LEVEL_DECLARATIONS",
+  "targetPackage": "baz"
+}
@@ -0,0 +1,4 @@
+package bar
+
+class X
+
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,52 @@
+package foo
+
+import foo.O.objectExtensionMember2
+
+fun test() {
+    A().classMember()
+    A().classExtension()
+    O.objectMember1()
+    O.objectMember2()
+    O.objectExtension()
+    A.companionMember()
+    A.companionExtension()
+    J().javaClassMember()
+    J.javaClassStaticMember()
+    topLevel()
+    with(O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(A) { 1.companionExtensionMember() }
+
+    A()::classMember
+    A::classMember
+    A()::classExtension
+    A::classExtension
+    O::objectMember1
+    O::objectMember2
+    O::objectExtension
+    A.Companion::companionMember
+    (A)::companionMember
+    A.Companion::companionExtension
+    (A)::companionExtension
+    J()::javaClassMember
+    J::javaClassMember
+    J::javaClassStaticMember
+    //::topLevel // not usable without import
+
+    with(A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,57 @@
+package bar
+
+import foo.O.objectExtensionMember2
+import foo.classExtension
+import foo.companionExtension
+import foo.objectExtension
+
+class X
+
+fun <caret>test() {
+    foo.A().classMember()
+    foo.A().classExtension()
+    foo.O.objectMember1()
+    foo.O.objectMember2()
+    foo.O.objectExtension()
+    foo.A.companionMember()
+    foo.A.companionExtension()
+    foo.J().javaClassMember()
+    foo.J.javaClassStaticMember()
+    foo.topLevel()
+    with(foo.O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(foo.A) { 1.companionExtensionMember() }
+
+    foo.A()::classMember
+    foo.A::classMember
+    foo.A()::classExtension
+    foo.A::classExtension
+    foo.O::objectMember1
+    foo.O::objectMember2
+    foo.O::objectExtension
+    foo.A.Companion::companionMember
+    (foo.A)::companionMember
+    foo.A.Companion::companionExtension
+    (foo.A)::companionExtension
+    foo.J()::javaClassMember
+    foo.J::javaClassMember
+    foo.J::javaClassStaticMember
+    //::topLevel // not usable without import
+
+    with(foo.A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(foo.J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,5 @@
+{
+  "mainFile": "bar/usages.kt",
+  "type": "MOVE_KOTLIN_TOP_LEVEL_DECLARATIONS",
+  "targetPackage": "foo"
+}
@@ -0,0 +1,4 @@
+package bar
+
+class X
+
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,52 @@
+package foo
+
+import foo.O.objectExtensionMember2
+
+fun test() {
+    A().classMember()
+    A().classExtension()
+    O.objectMember1()
+    O.objectMember2()
+    O.objectExtension()
+    A.companionMember()
+    A.companionExtension()
+    J().javaClassMember()
+    J.javaClassStaticMember()
+    topLevel()
+    with(O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(A) { 1.companionExtensionMember() }
+
+    A()::classMember
+    A::classMember
+    A()::classExtension
+    A::classExtension
+    O::objectMember1
+    O::objectMember2
+    O::objectExtension
+    A.Companion::companionMember
+    (A)::companionMember
+    A.Companion::companionExtension
+    (A)::companionExtension
+    J()::javaClassMember
+    J::javaClassMember
+    J::javaClassStaticMember
+    ::topLevel
+
+    with(A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,56 @@
+package bar
+
+import foo.*
+import foo.O.objectMember2
+import foo.O.objectExtensionMember2
+
+class X
+
+fun <caret>test() {
+    A().classMember()
+    A().classExtension()
+    O.objectMember1()
+    objectMember2()
+    O.objectExtension()
+    A.companionMember()
+    A.companionExtension()
+    J().javaClassMember()
+    J.javaClassStaticMember()
+    topLevel()
+    with(O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(A) { 1.companionExtensionMember() }
+
+    A()::classMember
+    A::classMember
+    A()::classExtension
+    A::classExtension
+    O::objectMember1
+    ::objectMember2
+    O::objectExtension
+    A.Companion::companionMember
+    (A)::companionMember
+    A.Companion::companionExtension
+    (A)::companionExtension
+    J()::javaClassMember
+    J::javaClassMember
+    J::javaClassStaticMember
+    ::topLevel
+
+    with(A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,5 @@
+{
+  "mainFile": "bar/usages.kt",
+  "type": "MOVE_KOTLIN_TOP_LEVEL_DECLARATIONS",
+  "targetPackage": "foo"
+}
@@ -0,0 +1,59 @@
+package bar
+
+import foo.A
+import foo.J
+import foo.O
+import foo.O.objectExtensionMember2
+import foo.classExtension
+import foo.companionExtension
+import foo.objectExtension
+import foo.topLevel
+
+fun test() {
+    A().classMember()
+    A().classExtension()
+    O.objectMember1()
+    O.objectMember2()
+    O.objectExtension()
+    A.companionMember()
+    A.companionExtension()
+    J().javaClassMember()
+    J.javaClassStaticMember()
+    topLevel()
+    with(O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(A) { 1.companionExtensionMember() }
+
+    A()::classMember
+    A::classMember
+    A()::classExtension
+    A::classExtension
+    O::objectMember1
+    O::objectMember2
+    O::objectExtension
+    A.Companion::companionMember
+    (A)::companionMember
+    A.Companion::companionExtension
+    (A)::companionExtension
+    J()::javaClassMember
+    J::javaClassMember
+    J::javaClassStaticMember
+    ::topLevel
+
+    with(A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,4 @@
+package foo
+
+class X
+
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,55 @@
+package foo
+
+import foo.O.objectMember2
+import foo.O.objectExtensionMember2
+
+class X
+
+fun <caret>test() {
+    A().classMember()
+    A().classExtension()
+    O.objectMember1()
+    objectMember2()
+    O.objectExtension()
+    A.companionMember()
+    A.companionExtension()
+    J().javaClassMember()
+    J.javaClassStaticMember()
+    topLevel()
+    with(O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(A) { 1.companionExtensionMember() }
+
+    A()::classMember
+    A::classMember
+    A()::classExtension
+    A::classExtension
+    O::objectMember1
+    ::objectMember2
+    O::objectExtension
+    A.Companion::companionMember
+    (A)::companionMember
+    A.Companion::companionExtension
+    (A)::companionExtension
+    J()::javaClassMember
+    J::javaClassMember
+    J::javaClassStaticMember
+    ::topLevel
+
+    with(A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,5 @@
+{
+  "mainFile": "foo/usages.kt",
+  "type": "MOVE_KOTLIN_TOP_LEVEL_DECLARATIONS",
+  "targetPackage": "bar"
+}
@@ -0,0 +1,59 @@
+package bar
+
+import foo.A
+import foo.J
+import foo.O
+import foo.O.objectExtensionMember2
+import foo.classExtension
+import foo.companionExtension
+import foo.objectExtension
+import foo.topLevel
+
+fun test() {
+    A().classMember()
+    A().classExtension()
+    O.objectMember1()
+    O.objectMember2()
+    O.objectExtension()
+    A.companionMember()
+    A.companionExtension()
+    J().javaClassMember()
+    J.javaClassStaticMember()
+    topLevel()
+    with(O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(A) { 1.companionExtensionMember() }
+
+    A()::classMember
+    A::classMember
+    A()::classExtension
+    A::classExtension
+    O::objectMember1
+    O::objectMember2
+    O::objectExtension
+    A.Companion::companionMember
+    (A)::companionMember
+    A.Companion::companionExtension
+    (A)::companionExtension
+    J()::javaClassMember
+    J::javaClassMember
+    J::javaClassStaticMember
+    ::topLevel
+
+    with(A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,4 @@
+package foo
+
+class X
+
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,11 @@
+package foo;
+
+public class J {
+    public void javaClassMember() {
+
+    }
+
+    public static void javaClassStaticMember() {
+
+    }
+}
@@ -0,0 +1,54 @@
+package foo
+
+import foo.O.objectExtensionMember2
+
+class X
+
+fun <caret>test() {
+    foo.A().classMember()
+    foo.A().classExtension()
+    foo.O.objectMember1()
+    foo.O.objectMember2()
+    foo.O.objectExtension()
+    foo.A.companionMember()
+    foo.A.companionExtension()
+    foo.J().javaClassMember()
+    foo.J.javaClassStaticMember()
+    foo.topLevel()
+    with(foo.O) { 1.objectExtensionMember1() }
+    1.objectExtensionMember2()
+    with(foo.A) { 1.companionExtensionMember() }
+
+    foo.A()::classMember
+    foo.A::classMember
+    foo.A()::classExtension
+    foo.A::classExtension
+    foo.O::objectMember1
+    foo.O::objectMember2
+    foo.O::objectExtension
+    foo.A.Companion::companionMember
+    (foo.A)::companionMember
+    foo.A.Companion::companionExtension
+    (foo.A)::companionExtension
+    foo.J()::javaClassMember
+    foo.J::javaClassMember
+    foo.J::javaClassStaticMember
+    ::topLevel
+
+    with(foo.A()) {
+        classMember()
+        this.classMember()
+        classExtension()
+        this.classExtension()
+
+        this::classMember
+        this::classExtension
+    }
+
+    with(foo.J()) {
+        javaClassMember()
+        this.javaClassMember()
+
+        this::javaClassMember
+    }
+}
@@ -0,0 +1,51 @@
+package foo
+
+class A {
+    fun classMember() {
+
+    }
+
+    companion object {
+        fun companionMember() {
+
+        }
+
+        fun Int.companionExtensionMember() {
+
+        }
+    }
+}
+
+fun A.classExtension() {
+
+}
+
+object O {
+    fun objectMember1() {
+
+    }
+
+    fun objectMember2() {
+
+    }
+
+    fun Int.objectExtensionMember1() {
+
+    }
+
+    fun Int.objectExtensionMember2() {
+
+    }
+}
+
+fun O.objectExtension() {
+
+}
+
+fun A.Companion.companionExtension() {
+
+}
+
+fun topLevel() {
+
+}
@@ -0,0 +1,5 @@
+{
+  "mainFile": "foo/usages.kt",
+  "type": "MOVE_KOTLIN_TOP_LEVEL_DECLARATIONS",
+  "targetPackage": "bar"
+}
@@ -420,6 +420,42 @@ public class MoveTestGenerated extends AbstractMoveTest {
        doTest(fileName);
    }

+    @TestMetadata("kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentSourceAndTargetWithFqNames/differentSourceAndTargetWithFqNames.test")
+    public void testKotlin_moveTopLevelDeclarations_callsAndCallableRefs_internalUsages_differentSourceAndTargetWithFqNames_DifferentSourceAndTargetWithFqNames() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/refactoring/move/kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentSourceAndTargetWithFqNames/differentSourceAndTargetWithFqNames.test");
+        doTest(fileName);
+    }
+
+    @TestMetadata("kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentSourceAndTargetWithImports/differentSourceAndTargetWithImports.test")
+    public void testKotlin_moveTopLevelDeclarations_callsAndCallableRefs_internalUsages_differentSourceAndTargetWithImports_DifferentSourceAndTargetWithImports() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/refactoring/move/kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentSourceAndTargetWithImports/differentSourceAndTargetWithImports.test");
+        doTest(fileName);
+    }
+
+    @TestMetadata("kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentSourceWithFqNames/differentSourceWithFqNames.test")
+    public void testKotlin_moveTopLevelDeclarations_callsAndCallableRefs_internalUsages_differentSourceWithFqNames_DifferentSourceWithFqNames() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/refactoring/move/kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentSourceWithFqNames/differentSourceWithFqNames.test");
+        doTest(fileName);
+    }
+
+    @TestMetadata("kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentSourceWithImports/differentSourceWithImports.test")
+    public void testKotlin_moveTopLevelDeclarations_callsAndCallableRefs_internalUsages_differentSourceWithImports_DifferentSourceWithImports() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/refactoring/move/kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentSourceWithImports/differentSourceWithImports.test");
+        doTest(fileName);
+    }
+
+    @TestMetadata("kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentTarget/differentTarget.test")
+    public void testKotlin_moveTopLevelDeclarations_callsAndCallableRefs_internalUsages_differentTarget_DifferentTarget() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/refactoring/move/kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentTarget/differentTarget.test");
+        doTest(fileName);
+    }
+
+    @TestMetadata("kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentTargetWithFqNames/differentTargetWithFqNames.test")
+    public void testKotlin_moveTopLevelDeclarations_callsAndCallableRefs_internalUsages_differentTargetWithFqNames_DifferentTargetWithFqNames() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/refactoring/move/kotlin/moveTopLevelDeclarations/callsAndCallableRefs/internalUsages/differentTargetWithFqNames/differentTargetWithFqNames.test");
+        doTest(fileName);
+    }
+
    @TestMetadata("kotlin/moveTopLevelDeclarations/misc/companionExtensionMemberRef/companionExtensionMemberRef.test")
    public void testKotlin_moveTopLevelDeclarations_misc_companionExtensionMemberRef_CompanionExtensionMemberRef() throws Exception {
        String fileName = KotlinTestUtils.navigationMetadata("idea/testData/refactoring/move/kotlin/moveTopLevelDeclarations/misc/companionExtensionMemberRef/companionExtensionMemberRef.test");