[IR] Hide regular class constructor with MFVC parameters

Signed-off-by: Evgeniy.Zhelenskiy <Evgeniy.Zhelenskiy@jetbrains.com>

#KT-1179

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultConstructorLowering.kt

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.ir.builders.declarations.addConstructor
 import org.jetbrains.kotlin.ir.builders.irBlockBody
 import org.jetbrains.kotlin.ir.builders.irDelegatingConstructorCall
 import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.isSingleFieldValueClass
 import org.jetbrains.kotlin.ir.util.constructors
 import org.jetbrains.kotlin.ir.util.copyAnnotationsFrom
 import org.jetbrains.kotlin.ir.util.hasDefaultValue
@@ -38,7 +37,7 @@ internal val jvmDefaultConstructorPhase = makeIrFilePhase(
 private class JvmDefaultConstructorLowering(val context: JvmBackendContext) : ClassLoweringPass {
 
     override fun lower(irClass: IrClass) {
-        if (irClass.kind != ClassKind.CLASS || irClass.visibility == DescriptorVisibilities.LOCAL || irClass.isSingleFieldValueClass || irClass.isInner ||
+        if (irClass.kind != ClassKind.CLASS || irClass.visibility == DescriptorVisibilities.LOCAL || irClass.isValue || irClass.isInner ||
             irClass.modality == Modality.SEALED
         )
             return
@@ -47,7 +46,7 @@ private class JvmDefaultConstructorLowering(val context: JvmBackendContext) : Cl
         if (DescriptorVisibilities.isPrivate(primaryConstructor.visibility))
             return
 
-        if (primaryConstructor.hasMangledParameters())
+        if ((context.multiFieldValueClassReplacements.originalConstructorForConstructorReplacement[primaryConstructor] ?: primaryConstructor).hasMangledParameters())
             return
 
         if (primaryConstructor.valueParameters.isEmpty() || !primaryConstructor.valueParameters.all { it.hasDefaultValue() })

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt

@@ -373,7 +373,9 @@ private class SyntheticAccessorTransformer(
         get() {
             if (this in context.hiddenConstructorsWithMangledParams.keys) return true
             return isOrShouldBeHiddenDueToOrigin && !DescriptorVisibilities.isPrivate(visibility)
-                    && !constructedClass.isValue && hasMangledParameters() && !constructedClass.isAnonymousObject
+                    && !constructedClass.isValue &&
+                    (context.multiFieldValueClassReplacements.originalConstructorForConstructorReplacement[this] ?: this)
+                        .hasMangledParameters() && !constructedClass.isAnonymousObject
         }
 
     private val IrConstructor.isOrShouldBeHiddenAsSealedClassConstructor: Boolean

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt

@@ -34,7 +34,7 @@ class MemoizedMultiFieldValueClassReplacements(
 
     val originalFunctionForStaticReplacement: MutableMap<IrFunction, IrFunction> = ConcurrentHashMap()
     val originalFunctionForMethodReplacement: MutableMap<IrFunction, IrFunction> = ConcurrentHashMap()
-    private val originalConstructorForConstructorReplacement: MutableMap<IrConstructor, IrConstructor> = ConcurrentHashMap()
+    val originalConstructorForConstructorReplacement: MutableMap<IrConstructor, IrConstructor> = ConcurrentHashMap()
 
     private fun IrValueParameter.grouped(
         name: String?,
@@ -152,6 +152,9 @@ class MemoizedMultiFieldValueClassReplacements(
 
         data class RegularMapping(val valueParameter: IrValueParameter) : RemappedParameter() {
             override val valueParameters: List<IrValueParameter> = listOf(valueParameter)
+            override fun toString(): String {
+                return "RegularMapping(valueParameter=${valueParameter.render()})"
+            }
         }
 
         data class MultiFieldValueClassMapping(
@@ -167,6 +170,16 @@ class MemoizedMultiFieldValueClassReplacements(
                     this(rootMfvcNode, makeTypeArgumentsFromType(type), valueParameters)
 
             val boxedType: IrSimpleType = rootMfvcNode.type.substitute(typeArguments) as IrSimpleType
+            override fun toString(): String {
+                return """MultiFieldValueClassMapping(
+                    |    rootMfvcNode=$rootMfvcNode,
+                    |    typeArguments=[${typeArguments.values.joinToString(",") { "\n        " + it.render() }}],
+                    |    valueParameters=[${valueParameters.joinToString(",") { "\n        " + it.render() }}],
+                    |    boxedType=${boxedType.render()}
+                    |)""".trimMargin()
+            }
+
+
         }
     }
 
@@ -196,11 +209,7 @@ class MemoizedMultiFieldValueClassReplacements(
 
     override fun createMethodReplacement(function: IrFunction): IrSimpleFunction = buildReplacement(function, function.origin) {
         originalFunctionForMethodReplacement[this] = function
-        dispatchReceiverParameter = function.dispatchReceiverParameter?.copyTo(this, index = -1)
-        val newFlattenedParameters = makeAndAddGroupedValueParametersFrom(function, includeDispatcherReceiver = false, mapOf(), this)
-        val receiver = dispatchReceiverParameter
-        val remappedParameters =
-            if (receiver != null) listOf(RemappedParameter.RegularMapping(receiver)) + newFlattenedParameters else newFlattenedParameters
+        val remappedParameters = makeMethodLikeRemappedParameters(function)
         bindingOldFunctionToParameterTemplateStructure[function] = remappedParameters
         bindingNewFunctionToParameterTemplateStructure[this] = remappedParameters
     }
@@ -210,17 +219,28 @@ class MemoizedMultiFieldValueClassReplacements(
             updateFrom(constructor)
             returnType = constructor.returnType
         }.apply {
-            val newFlattenedParameters = makeAndAddGroupedValueParametersFrom(constructor, includeDispatcherReceiver = false, mapOf(), this)
-            bindingOldFunctionToParameterTemplateStructure[constructor] = newFlattenedParameters
             parent = constructor.parent
+            val remappedParameters = makeMethodLikeRemappedParameters(constructor)
+            bindingOldFunctionToParameterTemplateStructure[constructor] = remappedParameters
             copyTypeParametersFrom(constructor)
             annotations = constructor.annotations
             originalConstructorForConstructorReplacement[this] = constructor
-            bindingNewFunctionToParameterTemplateStructure[this] = newFlattenedParameters
+            bindingNewFunctionToParameterTemplateStructure[this] = remappedParameters
+            if (constructor.metadata != null) {
+                metadata = constructor.metadata
+                constructor.metadata = null
+            }
         }
         return newConstructor
     }
 
+    private fun IrFunction.makeMethodLikeRemappedParameters(function: IrFunction): List<RemappedParameter> {
+        dispatchReceiverParameter = function.dispatchReceiverParameter?.copyTo(this, index = -1)
+        val newFlattenedParameters = makeAndAddGroupedValueParametersFrom(function, includeDispatcherReceiver = false, mapOf(), this)
+        val receiver = dispatchReceiverParameter
+        return if (receiver != null) listOf(RemappedParameter.RegularMapping(receiver)) + newFlattenedParameters else newFlattenedParameters
+    }
+
     /**
      * Get a function replacement for a function or a constructor.
      */
@@ -297,6 +317,12 @@ class MemoizedMultiFieldValueClassReplacements(
             createIntermediateNodeForMfvcPropertyOfRegularClass(parent, context, property)
         }
 
+    private val fieldsToRemove = ConcurrentHashMap<IrClass, MutableSet<IrField>>()
+    fun getFieldsToRemove(clazz: IrClass): Set<IrField> = fieldsToRemove[clazz] ?: emptySet()
+    fun addFieldToRemove(clazz: IrClass, field: IrField) {
+        fieldsToRemove.getOrPut(clazz) { ConcurrentHashMap<IrField, Unit>().keySet(Unit) }.add(field)
+    }
+
     fun getMfvcFieldNode(field: IrField): NameableMfvcNode? {
         val parent = field.parent
         val property = field.correspondingPropertySymbol?.owner