Use correct FQ name for running inner classes (KT-14153)

idea/src/org/jetbrains/kotlin/idea/run/JetRunConfiguration.java

@@ -233,19 +233,19 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
     @Nullable
     @Override
     public RefactoringElementListener getRefactoringElementListener(PsiElement element) {
-        FqName fqNameBeingRenamed;
+        String fqNameBeingRenamed;
         if (element instanceof KtDeclarationContainer) {
             fqNameBeingRenamed = KotlinRunConfigurationProducer.Companion.getStartClassFqName((KtDeclarationContainer) element);
         }
         else if (element instanceof PsiPackage) {
-            fqNameBeingRenamed = new FqName(((PsiPackage) element).getQualifiedName());
+            fqNameBeingRenamed = ((PsiPackage) element).getQualifiedName();
         }
         else {
             fqNameBeingRenamed = null;
         }
 
         if (fqNameBeingRenamed == null ||
-            !MAIN_CLASS_NAME.equals(fqNameBeingRenamed.asString()) && !MAIN_CLASS_NAME.startsWith(fqNameBeingRenamed.asString() + ".")) {
+            !MAIN_CLASS_NAME.equals(fqNameBeingRenamed) && !MAIN_CLASS_NAME.startsWith(fqNameBeingRenamed + ".")) {
             return null;
         }
 
@@ -279,9 +279,9 @@ public class JetRunConfiguration extends ModuleBasedConfiguration<RunConfigurati
 
     private void updateMainClassName(PsiElement element) {
         KtDeclarationContainer container = KotlinRunConfigurationProducer.Companion.getEntryPointContainer(element);
-        FqName name = KotlinRunConfigurationProducer.Companion.getStartClassFqName(container);
+        String name = KotlinRunConfigurationProducer.Companion.getStartClassFqName(container);
         if (name != null) {
-            MAIN_CLASS_NAME = name.asString();
+            MAIN_CLASS_NAME = name;
         }
     }
 

idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt

@@ -19,18 +19,18 @@ package org.jetbrains.kotlin.idea.run
 import com.intellij.execution.Location
 import com.intellij.execution.actions.ConfigurationContext
 import com.intellij.execution.actions.RunConfigurationProducer
-import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.DumbService
 import com.intellij.openapi.util.Ref
 import com.intellij.psi.PsiElement
+import com.intellij.psi.util.ClassUtil
 import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 
@@ -44,7 +44,10 @@ class KotlinRunConfigurationProducer : RunConfigurationProducer<JetRunConfigurat
         val container = getEntryPointContainer(location)
         val startClassFQName = getStartClassFqName(container) ?: return false
 
-        setupConfigurationByQName(module, configuration, startClassFQName)
+        configuration.setModule(module)
+        configuration.runClass = startClassFQName
+        configuration.setGeneratedName()
+
         return true
     }
 
@@ -61,18 +64,10 @@ class KotlinRunConfigurationProducer : RunConfigurationProducer<JetRunConfigurat
         return getEntryPointContainer(locationElement)
     }
 
-    private fun setupConfigurationByQName(module: Module,
-                                          configuration: JetRunConfiguration,
-                                          fqName: FqName) {
-        configuration.setModule(module)
-        configuration.runClass = fqName.asString()
-        configuration.setGeneratedName()
-    }
-
     override fun isConfigurationFromContext(configuration: JetRunConfiguration, context: ConfigurationContext): Boolean {
         val startClassFQName = getStartClassFqName(getEntryPointContainer(context.location)) ?: return false
 
-        return configuration.runClass == startClassFQName.asString() &&
+        return configuration.runClass == startClassFQName &&
                context.module ==  configuration.configurationModule.module
     }
 
@@ -97,15 +92,15 @@ class KotlinRunConfigurationProducer : RunConfigurationProducer<JetRunConfigurat
             return null
         }
 
-        fun getStartClassFqName(container: KtDeclarationContainer?): FqName? = when(container) {
+        fun getStartClassFqName(container: KtDeclarationContainer?): String? = when(container) {
             null -> null
-            is KtFile -> container.javaFileFacadeFqName
+            is KtFile -> container.javaFileFacadeFqName.asString()
             is KtClassOrObject -> {
                 if (container is KtObjectDeclaration && container.isCompanion()) {
                     val containerClass = container.getParentOfType<KtClass>(true)
-                    containerClass?.fqName
+                    containerClass?.toLightClass()?.let { ClassUtil.getJVMClassName(it) }
                 } else {
-                    container.fqName
+                    container.toLightClass()?.let { ClassUtil.getJVMClassName(it) }
                 }
             }
             else -> throw IllegalArgumentException("Invalid entry-point container: " + (container as PsiElement).text)

idea/testData/run/ClassesAndObjects/module/src/test.kt

@@ -7,10 +7,10 @@ object Foo {
         println("Foo")
     }
 
-    // RUN: q.Foo.InnerFoo
+    // RUN: q.Foo$InnerFoo
     class InnerFoo {
         companion object {
-            // RUN: q.Foo.InnerFoo
+            // RUN: q.Foo$InnerFoo
             @JvmStatic fun main(s: Array<String>) {
                 println("InnerFoo")
             }