Remove ModuleResult.Missing from commonization results

This result seems to not be used

^KT-51026

native/commonizer/src/org/jetbrains/kotlin/commonizer/ResultsConsumer.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.commonizer
 
 import org.jetbrains.kotlin.commonizer.konan.NativeSensitiveManifestData
 import org.jetbrains.kotlin.library.SerializedMetadata
-import java.io.File
 
 internal fun buildResultsConsumer(init: ResultsConsumerBuilder.() -> Unit): ResultsConsumer {
     return ResultsConsumerBuilder().apply(init).build()
@@ -16,17 +15,9 @@ internal fun buildResultsConsumer(init: ResultsConsumerBuilder.() -> Unit): Resu
 interface ResultsConsumer {
     enum class Status { NOTHING_TO_DO, DONE }
 
-    sealed class ModuleResult {
+    class ModuleResult(
-        abstract val libraryName: String
+        val libraryName: String, val metadata: SerializedMetadata, val manifest: NativeSensitiveManifestData
-
+    )
-        class Missing(val originalLocation: File) : ModuleResult() {
-            override val libraryName: String get() = originalLocation.name
-        }
-
-        class Commonized(
-            override val libraryName: String, val metadata: SerializedMetadata, val manifest: NativeSensitiveManifestData
-        ) : ModuleResult()
-    }
 
     /**
      * Consume a single [ModuleResult] for the specified [CommonizerTarget].

native/commonizer/src/org/jetbrains/kotlin/commonizer/facade.kt

@@ -94,7 +94,7 @@ internal fun serializeTarget(
         val manifestData = parameters.manifestProvider[outputTarget].buildManifest(libraryName)
         parameters.resultsConsumer.consume(
             parameters, outputTarget,
-            ResultsConsumer.ModuleResult.Commonized(libraryName, serializedMetadata, manifestData)
+            ResultsConsumer.ModuleResult(libraryName, serializedMetadata, manifestData)
         )
     }
     parameters.resultsConsumer.targetConsumed(parameters, outputTarget)

native/commonizer/src/org/jetbrains/kotlin/commonizer/konan/ModuleSerializer.kt

@@ -5,10 +5,7 @@
 
 package org.jetbrains.kotlin.commonizer.konan
 
-import org.jetbrains.kotlin.commonizer.CommonizerOutputFileLayout
+import org.jetbrains.kotlin.commonizer.*
-import org.jetbrains.kotlin.commonizer.CommonizerParameters
-import org.jetbrains.kotlin.commonizer.CommonizerTarget
-import org.jetbrains.kotlin.commonizer.ResultsConsumer
 import org.jetbrains.kotlin.library.SerializedMetadata
 import org.jetbrains.kotlin.library.impl.BaseWriterImpl
 import org.jetbrains.kotlin.library.impl.BuiltInsPlatform
@@ -20,20 +17,15 @@ internal class ModuleSerializer(
     private val destination: File,
 ) : ResultsConsumer {
     override fun consume(parameters: CommonizerParameters, target: CommonizerTarget, moduleResult: ResultsConsumer.ModuleResult) {
-        val librariesDestination = CommonizerOutputFileLayout.resolveCommonizedDirectory(destination, target)
+        val librariesDestination = CommonizerOutputFileLayout.resolveCommonizedDirectory(
-        when (moduleResult) {
+            destination,
-            is ResultsConsumer.ModuleResult.Commonized -> {
+            target,
-                val libraryDestination = librariesDestination.resolve(moduleResult.fileSystemCompatibleLibraryName)
+        )
-                writeLibrary(moduleResult.metadata, moduleResult.manifest, libraryDestination)
+        writeLibrary(
-            }
+            moduleResult.metadata,
-            is ResultsConsumer.ModuleResult.Missing -> {
+            moduleResult.manifest,
-                val missingModuleSourceLocation = moduleResult.originalLocation
+            librariesDestination.resolve(moduleResult.fileSystemCompatibleLibraryName)
-                val missingModuleDestinationLocation = librariesDestination.resolve(moduleResult.fileSystemCompatibleLibraryName)
+        )
-                if (!missingModuleDestinationLocation.exists()) {
-                    missingModuleSourceLocation.copyRecursively(librariesDestination.resolve(moduleResult.fileSystemCompatibleLibraryName))
-                }
-            }
-        }
     }
 }
 

native/commonizer/tests/org/jetbrains/kotlin/commonizer/AbstractCommonizationFromSourcesTest.kt

@@ -77,8 +77,7 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() {
         assertEquals(sharedTarget, results.sharedTarget)
 
         val sharedModuleAsExpected: SerializedMetadata = analyzedModules.commonizedModules.getValue(sharedTarget)
-        val sharedModuleByCommonizer: SerializedMetadata =
+        val sharedModuleByCommonizer: SerializedMetadata = results.modulesByTargets.getValue(sharedTarget).single().metadata
-            (results.modulesByTargets.getValue(sharedTarget).single() as ModuleResult.Commonized).metadata
 
         assertModulesAreEqual(sharedModuleAsExpected, sharedModuleByCommonizer, sharedTarget)
     }

native/commonizer/tests/org/jetbrains/kotlin/commonizer/AbstractInlineSourcesCommonizationTest.kt

@@ -9,7 +9,7 @@ import org.intellij.lang.annotations.Language
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.commonizer.AbstractInlineSourcesCommonizationTest.DependencyAwareInlineSourceTestFactory
 import org.jetbrains.kotlin.commonizer.AbstractInlineSourcesCommonizationTest.Parameters
-import org.jetbrains.kotlin.commonizer.ResultsConsumer.ModuleResult.Commonized
+import org.jetbrains.kotlin.commonizer.ResultsConsumer.ModuleResult
 import org.jetbrains.kotlin.commonizer.konan.NativeManifestDataProvider
 import org.jetbrains.kotlin.commonizer.utils.*
 import kotlin.test.assertIs
@@ -226,7 +226,7 @@ fun HierarchicalCommonizationResult.assertCommonized(
     val module = getTarget(target).firstOrNull { moduleResult -> moduleResult.libraryName == referenceModule.name }
         ?: fail("Missing ${referenceModule.name} in target $target")
 
-    val commonizedModule = assertIs<Commonized>(module, "Expected ${module.libraryName} to be 'Commonized'")
+    val commonizedModule = assertIs<ResultsConsumer.ModuleResult>(module, "Expected ${module.libraryName} to be 'Commonized'")
 
     assertModulesAreEqual(
         inlineSourceTest.createMetadata(referenceModule), commonizedModule.metadata, target
@@ -247,7 +247,7 @@ fun HierarchicalCommonizationResult.assertCommonized(
     moduleBuilder: InlineSourceBuilder.ModuleBuilder.() -> Unit
 ) = assertCommonized(parseCommonizerTarget(target), moduleBuilder)
 
-fun Collection<ResultsConsumer.ModuleResult>.assertSingleCommonizedModule(): Commonized {
+fun Collection<ResultsConsumer.ModuleResult>.assertSingleCommonizedModule(): ResultsConsumer.ModuleResult {
     kotlin.test.assertEquals(1, size, "Expected exactly one module. Found: ${this.map { it.libraryName }}")
     return assertIs(single(), "Expected single module to be 'Commonized'")
 }

native/commonizer/tests/org/jetbrains/kotlin/commonizer/CommonizerFacadeTest.kt

@@ -135,10 +135,7 @@ class CommonizerFacadeTest {
             val actualMissingModuleNames = mutableSetOf<String>()
 
             actualModuleResults.forEach { moduleResult ->
-                when (moduleResult) {
+                actualCommonizedModuleNames += moduleResult.libraryName
-                    is ModuleResult.Commonized -> actualCommonizedModuleNames += moduleResult.libraryName
-                    is ModuleResult.Missing -> actualMissingModuleNames += moduleResult.libraryName
-                }
             }
 
             assertEquals(expectedCommonizedModuleNames.size + expectedMissingModuleNames.size, actualModuleResults.size)

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/HierarchicalModuleCommonizationTest.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.commonizer.hierarchical
 
 import org.jetbrains.kotlin.commonizer.AbstractInlineSourcesCommonizationTest
-import org.jetbrains.kotlin.commonizer.ResultsConsumer.ModuleResult.Missing
 import org.jetbrains.kotlin.commonizer.ResultsConsumer.Status
 import org.jetbrains.kotlin.commonizer.assertCommonized
 import org.jetbrains.kotlin.commonizer.parseCommonizerTarget