[Commonizer] Intern duplicated CirContainingClassDetails instances

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

@@ -8,17 +8,8 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 
-// TODO: inline?
 data class CirContainingClassDetails(
     val kind: ClassKind,
     override val modality: Modality,
     val isData: Boolean
-) : CirHasModality {
+) : CirHasModality
-    companion object {
-        val DOES_NOT_MATTER = CirContainingClassDetails(
-            kind = ClassKind.CLASS,
-            modality = Modality.FINAL,
-            isData = false
-        )
-    }
-}

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

@@ -7,34 +7,25 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir.factory
 
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.*
 import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirClassConstructorImpl
 
 object CirClassConstructorFactory {
-    fun create(source: ClassConstructorDescriptor): CirClassConstructor {
+    fun create(source: ClassConstructorDescriptor): CirClassConstructor = create(
-        val containingClass: ClassDescriptor = source.containingDeclaration
+        annotations = source.annotations.map(CirAnnotationFactory::create),
-
+        typeParameters = source.typeParameters.mapNotNull { typeParameter ->
-        return create(
+            // save only type parameters that are contributed by the constructor itself
-            annotations = source.annotations.map(CirAnnotationFactory::create),
+            typeParameter.takeIf { it.containingDeclaration == source }?.let(CirTypeParameterFactory::create)
-            typeParameters = source.typeParameters.mapNotNull { typeParameter ->
+        },
-                // save only type parameters that are contributed by the constructor itself
+        visibility = source.visibility,
-                typeParameter.takeIf { it.containingDeclaration == source }?.let(CirTypeParameterFactory::create)
+        containingClassDetails = CirContainingClassDetailsFactory.create(source),
-            },
+        valueParameters = source.valueParameters.map(CirValueParameterFactory::create),
-            visibility = source.visibility,
+        hasStableParameterNames = source.hasStableParameterNames(),
-            containingClassDetails = CirContainingClassDetails(
+        hasSynthesizedParameterNames = source.hasSynthesizedParameterNames(),
-                kind = containingClass.kind,
+        isPrimary = source.isPrimary,
-                modality = containingClass.modality,
+        kind = source.kind
-                isData = containingClass.isData
+    )
-            ),
-            valueParameters = source.valueParameters.map(CirValueParameterFactory::create),
-            hasStableParameterNames = source.hasStableParameterNames(),
-            hasSynthesizedParameterNames = source.hasSynthesizedParameterNames(),
-            isPrimary = source.isPrimary,
-            kind = source.kind
-        )
-    }
 
     @Suppress("NOTHING_TO_INLINE")
     inline fun create(

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.descriptors.commonizer.cir.factory
+
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirContainingClassDetails
+import org.jetbrains.kotlin.descriptors.commonizer.utils.Interner
+
+object CirContainingClassDetailsFactory {
+    private val interner = Interner<CirContainingClassDetails>()
+
+    // speed optimization
+    val DOES_NOT_MATTER: CirContainingClassDetails = create(
+        kind = ClassKind.CLASS,
+        modality = Modality.FINAL,
+        isData = false
+    )
+
+    fun create(source: ClassConstructorDescriptor): CirContainingClassDetails = doCreate(source.containingDeclaration)
+
+    fun create(source: CallableMemberDescriptor): CirContainingClassDetails? {
+        val containingClass: ClassDescriptor = source.containingDeclaration as? ClassDescriptor ?: return null
+        return doCreate(containingClass)
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun doCreate(containingClass: ClassDescriptor): CirContainingClassDetails = create(
+        kind = containingClass.kind,
+        modality = containingClass.modality,
+        isData = containingClass.isData
+    )
+
+    fun create(
+        kind: ClassKind,
+        modality: Modality,
+        isData: Boolean
+    ): CirContainingClassDetails {
+        return interner.intern(
+            CirContainingClassDetails(
+                kind = kind,
+                modality = modality,
+                isData = isData
+            )
+        )
+    }
+}

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

@@ -12,32 +12,22 @@ import org.jetbrains.kotlin.descriptors.commonizer.utils.intern
 import org.jetbrains.kotlin.name.Name
 
 object CirFunctionFactory {
-    fun create(source: SimpleFunctionDescriptor): CirFunction {
+    fun create(source: SimpleFunctionDescriptor): CirFunction = create(
-        val containingClass: ClassDescriptor? = source.containingDeclaration as? ClassDescriptor
+        annotations = source.annotations.map(CirAnnotationFactory::create),
-
+        name = source.name.intern(),
-        return create(
+        typeParameters = source.typeParameters.map(CirTypeParameterFactory::create),
-            annotations = source.annotations.map(CirAnnotationFactory::create),
+        visibility = source.visibility,
-            name = source.name.intern(),
+        modality = source.modality,
-            typeParameters = source.typeParameters.map(CirTypeParameterFactory::create),
+        containingClassDetails = CirContainingClassDetailsFactory.create(source),
-            visibility = source.visibility,
+        valueParameters = source.valueParameters.map(CirValueParameterFactory::create),
-            modality = source.modality,
+        hasStableParameterNames = source.hasStableParameterNames(),
-            containingClassDetails = containingClass?.let {
+        hasSynthesizedParameterNames = source.hasSynthesizedParameterNames(),
-                CirContainingClassDetails(
+        isExternal = source.isExternal,
-                    kind = it.kind,
+        extensionReceiver = source.extensionReceiverParameter?.let(CirExtensionReceiverFactory::create),
-                    modality = it.modality,
+        returnType = CirTypeFactory.create(source.returnType!!),
-                    isData = it.isData
+        kind = source.kind,
-                )
+        modifiers = CirFunctionModifiersFactory.create(source),
-            },
+    )
-            valueParameters = source.valueParameters.map(CirValueParameterFactory::create),
-            hasStableParameterNames = source.hasStableParameterNames(),
-            hasSynthesizedParameterNames = source.hasSynthesizedParameterNames(),
-            isExternal = source.isExternal,
-            extensionReceiver = source.extensionReceiverParameter?.let(CirExtensionReceiverFactory::create),
-            returnType = CirTypeFactory.create(source.returnType!!),
-            kind = source.kind,
-            modifiers = CirFunctionModifiersFactory.create(source),
-        )
-    }
 
     @Suppress("NOTHING_TO_INLINE")
     inline fun create(

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

@@ -24,21 +24,13 @@ object CirPropertyFactory {
             )
         }
 
-        val containingClass: ClassDescriptor? = source.containingDeclaration as? ClassDescriptor
-
         return create(
             annotations = source.annotations.map(CirAnnotationFactory::create),
             name = source.name.intern(),
             typeParameters = source.typeParameters.map(CirTypeParameterFactory::create),
             visibility = source.visibility,
             modality = source.modality,
-            containingClassDetails = containingClass?.let {
+            containingClassDetails = CirContainingClassDetailsFactory.create(source),
-                CirContainingClassDetails(
-                    kind = it.kind,
-                    modality = it.modality,
-                    isData = it.isData
-                )
-            },
             isExternal = source.isExternal,
             extensionReceiver = source.extensionReceiverParameter?.let(CirExtensionReceiverFactory::create),
             returnType = CirTypeFactory.create(source.returnType!!),

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

@@ -8,8 +8,8 @@ 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.CirContainingClassDetails
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirClassConstructorFactory
+import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirContainingClassDetailsFactory
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache
 
 class ClassConstructorCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer<CirClassConstructor, CirClassConstructor>() {
@@ -25,7 +25,7 @@ class ClassConstructorCommonizer(cache: CirClassifiersCache) : AbstractStandardC
         annotations = emptyList(),
         typeParameters = typeParameters.result,
         visibility = visibility.result,
-        containingClassDetails = CirContainingClassDetails.DOES_NOT_MATTER,
+        containingClassDetails = CirContainingClassDetailsFactory.DOES_NOT_MATTER,
         valueParameters = valueParameters.result,
         hasStableParameterNames = hasStableParameterNames,
         hasSynthesizedParameterNames = hasSynthesizedParameterNames,

native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/LoweringVisibilityCommonizerTest.kt

@@ -9,9 +9,9 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities.*
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.descriptors.commonizer.cir.CirContainingClassDetails
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirFunctionOrProperty
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirHasVisibility
+import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirContainingClassDetailsFactory
 import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.unsupported
 import org.junit.Test
 
@@ -50,8 +50,12 @@ abstract class LoweringVisibilityCommonizerTest(
         override val typeParameters get() = unsupported()
         override val visibility = this@toMock
         override val modality get() = if (areMembersVirtual) Modality.OPEN else Modality.FINAL
-        override val containingClassDetails =
+        override val containingClassDetails = if (areMembersVirtual)
-            if (areMembersVirtual) CirContainingClassDetails(kind = ClassKind.CLASS, modality = Modality.OPEN, isData = false) else null
+            CirContainingClassDetailsFactory.create(
+                kind = ClassKind.CLASS,
+                modality = Modality.OPEN,
+                isData = false
+            ) else null
         override val isExternal get() = unsupported()
         override val extensionReceiver get() = unsupported()
         override val returnType get() = unsupported()