JVM Cli: Proper Main-class manifest attribute for JvmStatic entry point.

`findMainClass` could handle main entry point from object and companion
object, not just top-level function.

Fixes [KT-32376](https://youtrack.jetbrains.com/issue/KT-32376).

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/findMainClass.kt

@@ -9,17 +9,35 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext
 
 fun findMainClass(bindingContext: BindingContext, languageVersionSettings: LanguageVersionSettings, files: List<KtFile>): FqName? {
     val mainFunctionDetector = MainFunctionDetector(bindingContext, languageVersionSettings)
     return files.asSequence()
         .map { file ->
-            if (mainFunctionDetector.hasMain(file.declarations))
+            mainFunctionDetector.findMainFunction(file)?.let { mainFunction ->
-                JvmFileClassUtil.getFileClassInfoNoResolve(file).facadeClassFqName
+                if (mainFunction.isTopLevel) {
-            else
+                    JvmFileClassUtil.getFileClassInfoNoResolve(file).facadeClassFqName
-                null
+                } else {
+                    val parent = mainFunction.getParentOfType<KtClassOrObject>(strict = true)
+                    if (parent is KtObjectDeclaration && parent.isCompanion()) {
+                        mainFunction.fqName?.parent()?.parent()
+                    } else {
+                        mainFunction.fqName?.parent()
+                    }
+                }
+            }
         }
         .singleOrNull { it != null }
 }
+
+private fun MainFunctionDetector.findMainFunction(container: KtDeclarationContainer): KtNamedFunction? =
+    container.declarations.mapNotNull { declaration ->
+        when (declaration) {
+            is KtNamedFunction -> declaration.takeIf(::isMain)
+            is KtDeclarationContainer -> findMainFunction(declaration)
+            else -> null
+        }
+    }.singleOrNull()

compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.kt

@@ -52,10 +52,6 @@ class MainFunctionDetector {
         this.languageVersionSettings = languageVersionSettings
     }
 
-    fun hasMain(declarations: List<KtDeclaration>): Boolean {
-        return findMainFunction(declarations) != null
-    }
-
     @JvmOverloads
     fun isMain(
         function: KtNamedFunction,
@@ -178,9 +174,6 @@ class MainFunctionDetector {
         return null
     }
 
-    private fun findMainFunction(declarations: List<KtDeclaration>) =
-        declarations.filterIsInstance<KtNamedFunction>().find { isMain(it) }
-
     private fun isParameterNumberSuitsForMain(
         parametersCount: Int,
         isTopLevel: Boolean,

compiler/tests/org/jetbrains/kotlin/cli/CustomCliTest.kt

@@ -39,6 +39,71 @@ class CustomCliTest : TestCaseWithTmpdir() {
         compileAndCheckMainClass(listOf(main1Kt, main2Kt), expectedMainClass = null)
     }
 
+    fun testObjectJvmStaticFunctionMainClass() {
+        val mainKt = tmpdir.resolve("main.kt").apply {
+            writeText(
+                """
+                    object ObjectMain {
+                        @JvmStatic
+                        fun main(args: Array<String>) = println("hello")
+                    }
+                """
+            )
+        }
+        compileAndCheckMainClass(listOf(mainKt), expectedMainClass = "ObjectMain")
+    }
+
+    fun testCompanionObjectJvmStaticFunctionMainClass() {
+        val mainKt = tmpdir.resolve("main.kt").apply {
+            writeText(
+                """
+                    class Test {
+                        companion object {
+                            @JvmStatic
+                            fun main(args: Array<String>) = println("hello")
+                        }
+                    }
+                """
+            )
+        }
+        compileAndCheckMainClass(listOf(mainKt), expectedMainClass = "Test")
+    }
+
+    fun testInterfaceCompanionObjectJvmStaticFunctionMainClass() {
+        val mainKt = tmpdir.resolve("main.kt").apply {
+            writeText(
+                """
+                    interface Test {
+                        companion object {
+                            @JvmStatic
+                            fun main(args: Array<String>) = println("hello")
+                        }
+                    }
+                """
+            )
+        }
+        compileAndCheckMainClass(listOf(mainKt), expectedMainClass = "Test")
+    }
+
+    fun testMultipleMainsInOneFile() {
+        val mainKt = tmpdir.resolve("main.kt").apply {
+            writeText(
+                """
+                    object ObjectMain {
+                        @JvmStatic
+                        fun main(args: Array<String>) = println("hello")
+                    }
+                    object ObjectMain2 {
+                        @JvmStatic
+                        fun main(args: Array<String>) = println("hello2")
+                    }
+                    fun main(args: Array<String>) = println("hello3")
+                """
+            )
+        }
+        compileAndCheckMainClass(listOf(mainKt), expectedMainClass = null)
+    }
+
     private fun compileAndCheckMainClass(sourceFiles: List<File>, expectedMainClass: String?) {
         val jarFile = tmpdir.resolve("output.jar")
         val args = listOf("-include-runtime", "-d", jarFile.absolutePath) + sourceFiles.map { it.absolutePath }