[Commonizer] Simplify creation of individual commonizers

2020-05-08 15:32:37 +07:00
parent 735387b685
commit 413e6552ef
29 changed files with 79 additions and 143 deletions
@@ -17,12 +17,12 @@ abstract class AbstractFunctionOrPropertyCommonizer<T : CirFunctionOrProperty>(
    cache: CirClassifiersCache
 ) : AbstractStandardCommonizer<T, T>() {
    protected lateinit var name: Name
-    protected val modality = ModalityCommonizer.default()
+    protected val modality = ModalityCommonizer()
    protected val visibility = VisibilityCommonizer.lowering()
-    protected val extensionReceiver = ExtensionReceiverCommonizer.default(cache)
-    protected val returnType = TypeCommonizer.default(cache)
+    protected val extensionReceiver = ExtensionReceiverCommonizer(cache)
+    protected val returnType = TypeCommonizer(cache)
    protected lateinit var kind: CallableMemberDescriptor.Kind
-    protected val typeParameters = TypeParameterListCommonizer.default(cache)
+    protected val typeParameters = TypeParameterListCommonizer(cache)

    override fun initialize(first: T) {
        name = first.name
@@ -14,8 +14,8 @@ import org.jetbrains.kotlin.name.Name
 class ClassCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer<CirClass, CirClass>() {
    private lateinit var name: Name
    private lateinit var kind: ClassKind
-    private val typeParameters = TypeParameterListCommonizer.default(cache)
-    private val modality = ModalityCommonizer.default()
+    private val typeParameters = TypeParameterListCommonizer(cache)
+    private val modality = ModalityCommonizer()
    private val visibility = VisibilityCommonizer.equalizing()
    private var isInner = false
    private var isInline = false
@@ -15,8 +15,8 @@ class ClassConstructorCommonizer(cache: CirClassifiersCache) : AbstractStandardC
    private var isPrimary = false
    private lateinit var kind: CallableMemberDescriptor.Kind
    private val visibility = VisibilityCommonizer.equalizing()
-    private val typeParameters = TypeParameterListCommonizer.default(cache)
-    private val valueParameters = ValueParameterListCommonizer.default(cache)
+    private val typeParameters = TypeParameterListCommonizer(cache)
+    private val valueParameters = ValueParameterListCommonizer(cache)
    private var hasStableParameterNames = true
    private var hasSynthesizedParameterNames = false

@@ -97,7 +97,7 @@ internal class CommonizationVisitor(
            }

            for ((_, supertypesGroup) in supertypesMap) {
-                val commonSupertype = commonize(supertypesGroup.toList(), TypeCommonizer.default(root.cache))
+                val commonSupertype = commonize(supertypesGroup.toList(), TypeCommonizer(root.cache))
                if (commonSupertype != null)
                    commonClass.supertypes += commonSupertype
            }
@@ -10,16 +10,9 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirExtensionRec
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirType
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirExtensionReceiver.Companion.toReceiverNoAnnotations

-interface ExtensionReceiverCommonizer : Commonizer<CirExtensionReceiver?, CirExtensionReceiver?> {
-    companion object {
-        fun default(cache: CirClassifiersCache): ExtensionReceiverCommonizer = DefaultExtensionReceiverCommonizer(cache)
-    }
-}
-
-private class DefaultExtensionReceiverCommonizer(cache: CirClassifiersCache) :
-    ExtensionReceiverCommonizer,
+class ExtensionReceiverCommonizer(cache: CirClassifiersCache) :
    AbstractNullableCommonizer<CirExtensionReceiver, CirExtensionReceiver, CirType, CirType>(
-        wrappedCommonizerFactory = { TypeCommonizer.default(cache) },
+        wrappedCommonizerFactory = { TypeCommonizer(cache) },
        extractor = { it.type },
        builder = { it.toReceiverNoAnnotations() }
    )
@@ -11,8 +11,8 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirFunction

 class FunctionCommonizer(cache: CirClassifiersCache) : AbstractFunctionOrPropertyCommonizer<CirFunction>(cache) {
    private val annotations = AnnotationsCommonizer()
-    private val modifiers = FunctionModifiersCommonizer.default()
-    private val valueParameters = ValueParameterListCommonizer.default(cache)
+    private val modifiers = FunctionModifiersCommonizer()
+    private val valueParameters = ValueParameterListCommonizer(cache)
    private var hasStableParameterNames = true
    private var hasSynthesizedParameterNames = false

@@ -7,13 +7,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.core

 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirFunctionModifiers

-interface FunctionModifiersCommonizer : Commonizer<CirFunctionModifiers, CirFunctionModifiers> {
-    companion object {
-        fun default(): FunctionModifiersCommonizer = DefaultFunctionModifiersCommonizer()
-    }
-}
-
-private class DefaultFunctionModifiersCommonizer : FunctionModifiersCommonizer {
+class FunctionModifiersCommonizer : Commonizer<CirFunctionModifiers, CirFunctionModifiers> {
    private var modifiers: CirFunctionModifiersImpl? = null
    private var error = false

@@ -7,13 +7,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.core

 import org.jetbrains.kotlin.descriptors.Modality

-interface ModalityCommonizer : Commonizer<Modality, Modality> {
-    companion object {
-        fun default(): ModalityCommonizer = DefaultModalityCommonizer()
-    }
-}
-
-private class DefaultModalityCommonizer : ModalityCommonizer {
+class ModalityCommonizer : Commonizer<Modality, Modality> {
    private var temp: Modality? = null
    private var error = false

@@ -8,13 +8,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.core
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirModule
 import org.jetbrains.kotlin.name.Name

-interface ModuleCommonizer : Commonizer<CirModule, CirModule> {
-    companion object {
-        fun default(): ModuleCommonizer = DefaultModuleCommonizer()
-    }
-}
-
-private class DefaultModuleCommonizer : ModuleCommonizer, AbstractStandardCommonizer<CirModule, CirModule>() {
+class ModuleCommonizer : AbstractStandardCommonizer<CirModule, CirModule>() {
    private lateinit var name: Name

    override fun commonizationResult() = CirModule(name = name)
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirCommonProper
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirProperty

 class PropertyCommonizer(cache: CirClassifiersCache) : AbstractFunctionOrPropertyCommonizer<CirProperty>(cache) {
-    private val setter = PropertySetterCommonizer.default()
+    private val setter = PropertySetterCommonizer()
    private var isExternal = true

    override fun commonizationResult() = CirCommonProperty(
@@ -9,16 +9,8 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirDeclarationWithVisibility
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirSetter

-interface PropertySetterCommonizer : Commonizer<CirSetter?, CirSetter?> {
-    companion object {
-        fun default(): PropertySetterCommonizer = DefaultPropertySetterCommonizer()
-    }
-}
-
-private class DefaultPropertySetterCommonizer :
-    PropertySetterCommonizer,
-    AbstractNullableCommonizer<CirSetter, CirSetter, CirDeclarationWithVisibility, Visibility>(
-        wrappedCommonizerFactory = { VisibilityCommonizer.equalizing() },
-        extractor = { it },
-        builder = { CirSetter.createDefaultNoAnnotations(it) }
-    )
+class PropertySetterCommonizer : AbstractNullableCommonizer<CirSetter, CirSetter, CirDeclarationWithVisibility, Visibility>(
+    wrappedCommonizerFactory = { VisibilityCommonizer.equalizing() },
+    extractor = { it },
+    builder = { CirSetter.createDefaultNoAnnotations(it) }
+)
@@ -12,13 +12,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.InputTarget
 import org.jetbrains.kotlin.descriptors.commonizer.OutputTarget
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirRoot

-interface RootCommonizer : Commonizer<CirRoot, CirRoot> {
-    companion object {
-        fun default(): RootCommonizer = DefaultRootCommonizer()
-    }
-}
-
-private class DefaultRootCommonizer : RootCommonizer, AbstractStandardCommonizer<CirRoot, CirRoot>() {
+class RootCommonizer : AbstractStandardCommonizer<CirRoot, CirRoot>() {
    private val inputTargets = mutableSetOf<InputTarget>()
    private var konanBuiltInsProvider: BuiltInsProvider? = null

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.name.Name

 class TypeAliasCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer<CirTypeAlias, CirClass>() {
    private lateinit var name: Name
-    private val underlyingType = TypeCommonizer.default(cache)
+    private val underlyingType = TypeCommonizer(cache)
    private val visibility = VisibilityCommonizer.lowering(allowPrivate = true)

    override fun commonizationResult() = CirCommonClass(
@@ -9,16 +9,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.*
 import org.jetbrains.kotlin.descriptors.commonizer.utils.isUnderStandardKotlinPackages
 import org.jetbrains.kotlin.types.AbstractStrictEqualityTypeChecker

-interface TypeCommonizer : Commonizer<CirType, CirType> {
-    companion object {
-        fun default(cache: CirClassifiersCache): TypeCommonizer = DefaultTypeCommonizer(cache)
-    }
-}
-
-private class DefaultTypeCommonizer(private val cache: CirClassifiersCache) :
-    TypeCommonizer,
-    AbstractStandardCommonizer<CirType, CirType>() {
-
+class TypeCommonizer(private val cache: CirClassifiersCache) : AbstractStandardCommonizer<CirType, CirType>() {
    private lateinit var temp: CirType

    override fun commonizationResult() = temp
@@ -12,16 +12,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirTypeParamete
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance

-interface TypeParameterCommonizer : Commonizer<CirTypeParameter, CirTypeParameter> {
-    companion object {
-        fun default(cache: CirClassifiersCache): TypeParameterCommonizer = DefaultTypeParameterCommonizer(cache)
-    }
-}
-
-private class DefaultTypeParameterCommonizer(cache: CirClassifiersCache) :
-    TypeParameterCommonizer,
-    AbstractStandardCommonizer<CirTypeParameter, CirTypeParameter>() {
-
+class TypeParameterCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer<CirTypeParameter, CirTypeParameter>() {
    private lateinit var name: Name
    private var isReified = false
    private lateinit var variance: Variance
@@ -48,17 +39,5 @@ private class DefaultTypeParameterCommonizer(cache: CirClassifiersCache) :
 }

 private class TypeParameterUpperBoundsCommonizer(cache: CirClassifiersCache) : AbstractListCommonizer<CirType, CirType>(
-    singleElementCommonizerFactory = { TypeCommonizer.default(cache) }
+    singleElementCommonizerFactory = { TypeCommonizer(cache) }
 )
-
-interface TypeParameterListCommonizer : Commonizer<List<CirTypeParameter>, List<CirTypeParameter>> {
-    companion object {
-        fun default(cache: CirClassifiersCache): TypeParameterListCommonizer = DefaultTypeParameterListCommonizer(cache)
-    }
-}
-
-private class DefaultTypeParameterListCommonizer(cache: CirClassifiersCache) :
-    TypeParameterListCommonizer,
-    AbstractListCommonizer<CirTypeParameter, CirTypeParameter>(
-        singleElementCommonizerFactory = { TypeParameterCommonizer.default(cache) }
-    )
@@ -0,0 +1,13 @@
+/*
+ * 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.core
+
+import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirClassifiersCache
+import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirTypeParameter
+
+class TypeParameterListCommonizer(cache: CirClassifiersCache) : AbstractListCommonizer<CirTypeParameter, CirTypeParameter>(
+    singleElementCommonizerFactory = { TypeParameterCommonizer(cache) }
+)
@@ -12,18 +12,9 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirValueParamet
 import org.jetbrains.kotlin.descriptors.commonizer.utils.isNull
 import org.jetbrains.kotlin.name.Name

-interface ValueParameterCommonizer : Commonizer<CirValueParameter, CirValueParameter> {
-    companion object {
-        fun default(cache: CirClassifiersCache): ValueParameterCommonizer = DefaultValueParameterCommonizer(cache)
-    }
-}
-
-private class DefaultValueParameterCommonizer(cache: CirClassifiersCache) :
-    ValueParameterCommonizer,
-    AbstractStandardCommonizer<CirValueParameter, CirValueParameter>() {
-
+class ValueParameterCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer<CirValueParameter, CirValueParameter>() {
    private lateinit var name: Name
-    private val returnType = TypeCommonizer.default(cache)
+    private val returnType = TypeCommonizer(cache)
    private var varargElementType: CirType? = null
    private var isCrossinline = true
    private var isNoinline = true
@@ -57,15 +48,3 @@ private class DefaultValueParameterCommonizer(cache: CirClassifiersCache) :
        return result
    }
 }
-
-interface ValueParameterListCommonizer : Commonizer<List<CirValueParameter>, List<CirValueParameter>> {
-    companion object {
-        fun default(cache: CirClassifiersCache): ValueParameterListCommonizer = DefaultValueParameterListCommonizer(cache)
-    }
-}
-
-private class DefaultValueParameterListCommonizer(cache: CirClassifiersCache) :
-    ValueParameterListCommonizer,
-    AbstractListCommonizer<CirValueParameter, CirValueParameter>(
-        singleElementCommonizerFactory = { ValueParameterCommonizer.default(cache) }
-    )
@@ -0,0 +1,13 @@
+/*
+ * 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.core
+
+import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirClassifiersCache
+import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirValueParameter
+
+class ValueParameterListCommonizer(cache: CirClassifiersCache) : AbstractListCommonizer<CirValueParameter, CirValueParameter>(
+    singleElementCommonizerFactory = { ValueParameterCommonizer(cache) }
+)
@@ -26,7 +26,7 @@ internal fun buildRootNode(
    storageManager = storageManager,
    descriptors = targetProviders,
    targetDeclarationProducer = { CirRoot(it.target, it.builtInsClass.name, it.builtInsProvider) },
-    commonValueProducer = { commonize(it, RootCommonizer.default()) },
+    commonValueProducer = { commonize(it, RootCommonizer()) },
    recursionMarker = null,
    nodeProducer = ::CirRootNode
 )
@@ -38,7 +38,7 @@ internal fun buildModuleNode(
    storageManager = storageManager,
    descriptors = modules,
    targetDeclarationProducer = ::CirModule,
-    commonValueProducer = { commonize(it, ModuleCommonizer.default()) },
+    commonValueProducer = { commonize(it, ModuleCommonizer()) },
    recursionMarker = null,
    nodeProducer = ::CirModuleNode
 )
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirType
 import org.jetbrains.kotlin.descriptors.commonizer.utils.mockClassType
 import org.junit.Test

-class DefaultExtensionReceiverCommonizerTest : AbstractCommonizerTest<CirExtensionReceiver?, CirExtensionReceiver?>() {
+class ExtensionReceiverCommonizerTest : AbstractCommonizerTest<CirExtensionReceiver?, CirExtensionReceiver?>() {

    @Test
    fun nullReceiver() = doTestSuccess(
@@ -50,7 +50,7 @@ class DefaultExtensionReceiverCommonizerTest : AbstractCommonizerTest<CirExtensi
        mockExtensionReceiver("kotlin.String")
    )

-    override fun createCommonizer() = ExtensionReceiverCommonizer.default(EMPTY_CLASSIFIERS_CACHE)
+    override fun createCommonizer() = ExtensionReceiverCommonizer(EMPTY_CLASSIFIERS_CACHE)
 }

 private fun mockExtensionReceiver(typeFqName: String) = CirExtensionReceiver(
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.core.CirTestFunctionModifiers
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirFunctionModifiers
 import org.junit.Test

-class DefaultFunctionModifiersCommonizerTest : AbstractCommonizerTest<CirFunctionModifiers, CirFunctionModifiers>() {
+class FunctionModifiersCommonizerTest : AbstractCommonizerTest<CirFunctionModifiers, CirFunctionModifiers>() {

    @Test
    fun allDefault() = doTestSuccess(
@@ -161,7 +161,7 @@ class DefaultFunctionModifiersCommonizerTest : AbstractCommonizerTest<CirFunctio
        mockFunctionModifiers()
    )

-    override fun createCommonizer() = FunctionModifiersCommonizer.default()
+    override fun createCommonizer() = FunctionModifiersCommonizer()
    override fun isEqual(a: CirFunctionModifiers?, b: CirFunctionModifiers?) = (a === b) || (a != null && b != null && areEqual(a, b))
 }

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Modality.*
 import org.junit.Test

-class DefaultModalityCommonizerTest : AbstractCommonizerTest<Modality, Modality>() {
+class ModalityCommonizerTest : AbstractCommonizerTest<Modality, Modality>() {

    @Test
    fun onlyFinal() = doTestSuccess(FINAL, FINAL, FINAL, FINAL)
@@ -38,5 +38,5 @@ class DefaultModalityCommonizerTest : AbstractCommonizerTest<Modality, Modality>
    @Test
    fun openAndFinal() = doTestSuccess(FINAL, OPEN, OPEN, FINAL)

-    override fun createCommonizer() = ModalityCommonizer.default()
+    override fun createCommonizer() = ModalityCommonizer()
 }
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirSetter
 import org.junit.Test

-class DefaultPropertySetterCommonizerTest : AbstractCommonizerTest<CirSetter?, CirSetter?>() {
+class PropertySetterCommonizerTest : AbstractCommonizerTest<CirSetter?, CirSetter?>() {

    @Test
    fun absentOnly() = super.doTestSuccess(null, null, null, null)
@@ -66,5 +66,5 @@ class DefaultPropertySetterCommonizerTest : AbstractCommonizerTest<CirSetter?, C
            shouldFailOnFirstVariant = false
        )

-    override fun createCommonizer() = PropertySetterCommonizer.default()
+    override fun createCommonizer() = PropertySetterCommonizer()
 }
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.junit.Test

-class DefaultRootCommonizerTest : AbstractCommonizerTest<CirRoot, CirRoot>() {
+class RootCommonizerTest : AbstractCommonizerTest<CirRoot, CirRoot>() {

    @Test
    fun allAreNative() = doTestSuccess(
@@ -148,7 +148,7 @@ class DefaultRootCommonizerTest : AbstractCommonizerTest<CirRoot, CirRoot>() {
        JVM_BUILT_INS.toMock(InputTarget("jvm3"))
    )

-    override fun createCommonizer() = RootCommonizer.default()
+    override fun createCommonizer() = RootCommonizer()

    override fun isEqual(a: CirRoot?, b: CirRoot?) =
        (a === b)
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.types.getAbbreviation
 import org.junit.Before
 import org.junit.Test

-class DefaultTypeCommonizerTest : AbstractCommonizerTest<CirType, CirType>() {
+class TypeCommonizerTest : AbstractCommonizerTest<CirType, CirType>() {

    private lateinit var cache: ClassifiersCacheImpl

@@ -426,7 +426,7 @@ class DefaultTypeCommonizerTest : AbstractCommonizerTest<CirType, CirType>() {
        )
    }

-    override fun createCommonizer() = TypeCommonizer.default(cache)
+    override fun createCommonizer() = TypeCommonizer(cache)

    override fun isEqual(a: CirType?, b: CirType?) = (a === b) || (a != null && b != null && areTypesEqual(cache, a, b))
 }
@@ -14,8 +14,8 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
 import org.junit.Test

-class DefaultTypeParameterCommonizerTest : AbstractCommonizerTest<CirTypeParameter, CirTypeParameter>() {
-    override fun createCommonizer() = TypeParameterCommonizer.default(EMPTY_CLASSIFIERS_CACHE)
+class TypeParameterCommonizerTest : AbstractCommonizerTest<CirTypeParameter, CirTypeParameter>() {
+    override fun createCommonizer() = TypeParameterCommonizer(EMPTY_CLASSIFIERS_CACHE)

    @Test
    fun allAreReified() = doTestSuccess(
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.utils.EMPTY_CLASSIFIERS_CACHE
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirTypeParameter
 import org.junit.Test

-class DefaultTypeParameterListCommonizerTest : AbstractCommonizerTest<List<CirTypeParameter>, List<CirTypeParameter>>() {
+class TypeParameterListCommonizerTest : AbstractCommonizerTest<List<CirTypeParameter>, List<CirTypeParameter>>() {

    @Test
    fun emptyValueParameters() = doTestSuccess(
@@ -108,13 +108,13 @@ class DefaultTypeParameterListCommonizerTest : AbstractCommonizerTest<List<CirTy
        )
    )

-    override fun createCommonizer() = TypeParameterListCommonizer.default(EMPTY_CLASSIFIERS_CACHE)
+    override fun createCommonizer() = TypeParameterListCommonizer(EMPTY_CLASSIFIERS_CACHE)

    private companion object {
        fun mockTypeParams(vararg params: Pair<String, String>): List<CirTypeParameter> {
            check(params.isNotEmpty())
            return params.map { (name, returnTypeFqName) ->
-                DefaultTypeParameterCommonizerTest.mockTypeParam(
+                TypeParameterCommonizerTest.mockTypeParam(
                    name = name,
                    upperBounds = listOf(returnTypeFqName)
                )
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.utils.mockClassType
 import org.jetbrains.kotlin.name.Name
 import org.junit.Test

-class DefaultValueParameterCommonizerTest : AbstractCommonizerTest<CirValueParameter, CirValueParameter>() {
+class ValueParameterCommonizerTest : AbstractCommonizerTest<CirValueParameter, CirValueParameter>() {

    @Test
    fun sameReturnType1() = doTestSuccess(
@@ -139,7 +139,7 @@ class DefaultValueParameterCommonizerTest : AbstractCommonizerTest<CirValueParam
        mockValueParam("kotlin.String", declaresDefaultValue = true)
    )

-    override fun createCommonizer() = ValueParameterCommonizer.default(EMPTY_CLASSIFIERS_CACHE)
+    override fun createCommonizer() = ValueParameterCommonizer(EMPTY_CLASSIFIERS_CACHE)

    override fun isEqual(a: CirValueParameter?, b: CirValueParameter?) =
        (a === b) || (a != null && b != null && areEqual(EMPTY_CLASSIFIERS_CACHE, a, b))
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.core.CirTestValueParameter.Co
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirValueParameter
 import org.junit.Test

-class DefaultValueParameterListCommonizerTest : AbstractCommonizerTest<List<CirValueParameter>, List<CirValueParameter>>() {
+class ValueParameterListCommonizerTest : AbstractCommonizerTest<List<CirValueParameter>, List<CirValueParameter>>() {

    @Test
    fun emptyValueParameters() = doTestSuccess(
@@ -164,7 +164,7 @@ class DefaultValueParameterListCommonizerTest : AbstractCommonizerTest<List<CirV
        )
    )

-    override fun createCommonizer() = ValueParameterListCommonizer.default(EMPTY_CLASSIFIERS_CACHE)
+    override fun createCommonizer() = ValueParameterListCommonizer(EMPTY_CLASSIFIERS_CACHE)

    override fun isEqual(a: List<CirValueParameter>?, b: List<CirValueParameter>?): Boolean {
        if (a === b)
@@ -184,7 +184,7 @@ class DefaultValueParameterListCommonizerTest : AbstractCommonizerTest<List<CirV
        fun mockValueParams(vararg params: Pair<String, String>): List<CirValueParameter> {
            check(params.isNotEmpty())
            return params.map { (name, returnTypeFqName) ->
-                DefaultValueParameterCommonizerTest.mockValueParam(
+                ValueParameterCommonizerTest.mockValueParam(
                    name = name,
                    returnTypeFqName = returnTypeFqName
                )