[Commonizer] Drop "kind" from CirClassConstructor

... as it is always CallableMemberDescriptor.Kind.DECLARATION
for serialized constructor declarations

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedClassDescriptor.kt

@@ -23,23 +23,23 @@ import org.jetbrains.kotlin.types.TypeConstructor
 import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 
 class CommonizedClassDescriptor(
-        targetComponents: TargetDeclarationsBuilderComponents,
+    targetComponents: TargetDeclarationsBuilderComponents,
-        containingDeclaration: DeclarationDescriptor,
+    containingDeclaration: DeclarationDescriptor,
-        override val annotations: Annotations,
+    override val annotations: Annotations,
-        name: Name,
+    name: Name,
-        private val kind: ClassKind,
+    private val kind: ClassKind,
-        private val modality: Modality,
+    private val modality: Modality,
-        private val visibility: DescriptorVisibility,
+    private val visibility: DescriptorVisibility,
-        private val isCompanion: Boolean,
+    private val isCompanion: Boolean,
-        private val isData: Boolean,
+    private val isData: Boolean,
-        private val isInline: Boolean,
+    private val isInline: Boolean,
-        private val isInner: Boolean,
+    private val isInner: Boolean,
-        isExternal: Boolean,
+    isExternal: Boolean,
-        private val isExpect: Boolean,
+    private val isExpect: Boolean,
-        private val isActual: Boolean,
+    private val isActual: Boolean,
-        cirDeclaredTypeParameters: List<CirTypeParameter>,
+    cirDeclaredTypeParameters: List<CirTypeParameter>,
-        companionObjectName: Name?,
+    companionObjectName: Name?,
-        cirSupertypes: Collection<CirType>
+    cirSupertypes: Collection<CirType>
 ) : ClassDescriptorBase(targetComponents.storageManager, containingDeclaration, name, SourceElement.NO_SOURCE, isExternal) {
     private lateinit var _unsubstitutedMemberScope: CommonizedMemberScope
     private lateinit var constructors: Collection<ClassConstructorDescriptor>
@@ -147,6 +147,12 @@ class CommonizedClassDescriptor(
 class CommonizedClassConstructorDescriptor(
     containingDeclaration: ClassDescriptor,
     annotations: Annotations,
-    isPrimary: Boolean,
+    isPrimary: Boolean
-    kind: CallableMemberDescriptor.Kind
+) : ClassConstructorDescriptorImpl(
-) : ClassConstructorDescriptorImpl(containingDeclaration, null, annotations, isPrimary, kind, SourceElement.NO_SOURCE)
+    containingDeclaration,
+    null,
+    annotations,
+    isPrimary,
+    CallableMemberDescriptor.Kind.DECLARATION,
+    SourceElement.NO_SOURCE
+)

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/classDescriptors.kt

@@ -105,8 +105,7 @@ private fun CirClassConstructor.buildDescriptor(
     val constructorDescriptor = CommonizedClassConstructorDescriptor(
         containingDeclaration = containingDeclaration,
         annotations = annotations.buildDescriptors(targetComponents),
-        isPrimary = isPrimary,
+        isPrimary = isPrimary
-        kind = kind
     )
 
     constructorDescriptor.isExpect = isExpect

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirClassConstructor.kt

@@ -5,8 +5,6 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.cir
 
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-
 interface CirClassConstructor :
     CirDeclaration,
     CirHasAnnotations,
@@ -16,6 +14,5 @@ interface CirClassConstructor :
     CirCallableMemberWithParameters {
 
     val isPrimary: Boolean
-    val kind: CallableMemberDescriptor.Kind
     override val containingClassDetails: CirContainingClassDetails // non-nullable
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassConstructorFactory.kt

@@ -12,30 +12,34 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.*
 import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirClassConstructorImpl
 
 object CirClassConstructorFactory {
-    fun create(source: ClassConstructorDescriptor): CirClassConstructor = create(
+    fun create(source: ClassConstructorDescriptor): CirClassConstructor {
-        annotations = source.annotations.map(CirAnnotationFactory::create),
+        check(source.kind == CallableMemberDescriptor.Kind.DECLARATION) {
-        typeParameters = source.typeParameters.mapNotNull { typeParameter ->
+            "Unexpected ${CallableMemberDescriptor.Kind::class.java} for class constructor $source, ${source::class.java}: ${source.kind}"
-            // save only type parameters that are contributed by the constructor itself
+        }
-            typeParameter.takeIf { it.containingDeclaration == source }?.let(CirTypeParameterFactory::create)
+
-        },
+        return create(
-        visibility = source.visibility,
+            annotations = source.annotations.map(CirAnnotationFactory::create),
-        containingClassDetails = CirContainingClassDetailsFactory.create(source),
+            typeParameters = source.typeParameters.mapNotNull { typeParameter ->
-        valueParameters = source.valueParameters.map(CirValueParameterFactory::create),
+                // save only type parameters that are contributed by the constructor itself
-        hasStableParameterNames = source.hasStableParameterNames(),
+                typeParameter.takeIf { it.containingDeclaration == source }?.let(CirTypeParameterFactory::create)
-        isPrimary = source.isPrimary,
+            },
-        kind = source.kind
+            visibility = source.visibility,
-    )
+            containingClassDetails = CirContainingClassDetailsFactory.create(source),
+            valueParameters = source.valueParameters.map(CirValueParameterFactory::create),
+            hasStableParameterNames = source.hasStableParameterNames(),
+            isPrimary = source.isPrimary
+        )
+    }
 
     @Suppress("NOTHING_TO_INLINE")
     inline fun create(
-            annotations: List<CirAnnotation>,
+        annotations: List<CirAnnotation>,
-            typeParameters: List<CirTypeParameter>,
+        typeParameters: List<CirTypeParameter>,
-            visibility: DescriptorVisibility,
+        visibility: DescriptorVisibility,
-            containingClassDetails: CirContainingClassDetails,
+        containingClassDetails: CirContainingClassDetails,
-            valueParameters: List<CirValueParameter>,
+        valueParameters: List<CirValueParameter>,
-            hasStableParameterNames: Boolean,
+        hasStableParameterNames: Boolean,
-            isPrimary: Boolean,
+        isPrimary: Boolean
-            kind: CallableMemberDescriptor.Kind
     ): CirClassConstructor {
         return CirClassConstructorImpl(
             annotations = annotations,
@@ -44,8 +48,7 @@ object CirClassConstructorFactory {
             containingClassDetails = containingClassDetails,
             valueParameters = valueParameters,
             hasStableParameterNames = hasStableParameterNames,
-            isPrimary = isPrimary,
+            isPrimary = isPrimary
-            kind = kind
         )
     }
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirClassConstructorImpl.kt

@@ -5,17 +5,15 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.cir.impl
 
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.DescriptorVisibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.*
 
 data class CirClassConstructorImpl(
-        override val annotations: List<CirAnnotation>,
+    override val annotations: List<CirAnnotation>,
-        override val typeParameters: List<CirTypeParameter>,
+    override val typeParameters: List<CirTypeParameter>,
-        override val visibility: DescriptorVisibility,
+    override val visibility: DescriptorVisibility,
-        override val containingClassDetails: CirContainingClassDetails,
+    override val containingClassDetails: CirContainingClassDetails,
-        override var valueParameters: List<CirValueParameter>,
+    override var valueParameters: List<CirValueParameter>,
-        override var hasStableParameterNames: Boolean,
+    override var hasStableParameterNames: Boolean,
-        override val isPrimary: Boolean,
+    override val isPrimary: Boolean
-        override val kind: CallableMemberDescriptor.Kind
 ) : CirClassConstructor

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassConstructorCommonizer.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.core
 
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassConstructor
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirClassConstructorFactory
@@ -14,7 +13,6 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCach
 
 class ClassConstructorCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer<CirClassConstructor, CirClassConstructor>() {
     private var isPrimary = false
-    private lateinit var kind: CallableMemberDescriptor.Kind
     private val visibility = VisibilityCommonizer.equalizing()
     private val typeParameters = TypeParameterListCommonizer(cache)
     private val valueParameters = CallableValueParametersCommonizer(cache)
@@ -30,21 +28,18 @@ class ClassConstructorCommonizer(cache: CirClassifiersCache) : AbstractStandardC
             containingClassDetails = CirContainingClassDetailsFactory.DOES_NOT_MATTER,
             valueParameters = valueParameters.valueParameters,
             hasStableParameterNames = valueParameters.hasStableParameterNames,
-            isPrimary = isPrimary,
+            isPrimary = isPrimary
-            kind = kind
         )
     }
 
     override fun initialize(first: CirClassConstructor) {
         isPrimary = first.isPrimary
-        kind = first.kind
     }
 
     override fun doCommonizeWith(next: CirClassConstructor): Boolean {
         return !next.containingClassDetails.kind.isSingleton // don't commonize constructors for objects and enum entries
                 && next.containingClassDetails.modality != Modality.SEALED // don't commonize constructors for sealed classes (not not their subclasses)
                 && isPrimary == next.isPrimary
-                && kind == next.kind
                 && visibility.commonizeWith(next)
                 && typeParameters.commonizeWith(next.typeParameters)
                 && valueParameters.commonizeWith(next)