From 734dff6282212f4ad530f88c8fb59b929e4ff465 Mon Sep 17 00:00:00 2001 From: Dmitriy Dolovov Date: Fri, 30 Oct 2020 00:59:49 +0300 Subject: [PATCH] [Commonizer] Use compact variants of collections to reduce memory footprint --- .../builder/CommonizedAnnotationDescriptor.kt | 5 +- .../CommonizedTypeParameterDescriptor.kt | 3 +- .../commonizer/builder/builderUtils.kt | 18 ++--- .../descriptors/commonizer/cir/CirClass.kt | 4 +- .../cir/factory/CirAnnotationFactory.kt | 11 +-- .../cir/factory/CirClassConstructorFactory.kt | 8 +- .../commonizer/cir/factory/CirClassFactory.kt | 41 +++++----- .../factory/CirExtensionReceiverFactory.kt | 3 +- .../cir/factory/CirFunctionFactory.kt | 31 ++++---- .../cir/factory/CirPropertyFactory.kt | 47 ++++++------ .../cir/factory/CirPropertyGetterFactory.kt | 3 +- .../cir/factory/CirPropertySetterFactory.kt | 17 +++-- .../cir/factory/CirTypeAliasFactory.kt | 5 +- .../commonizer/cir/factory/CirTypeFactory.kt | 4 +- .../cir/factory/CirTypeParameterFactory.kt | 5 +- .../cir/factory/CirValueParameterFactory.kt | 3 +- .../commonizer/cir/impl/CirClassImpl.kt | 13 +++- .../commonizer/cir/impl/CirDeclarationImpl.kt | 2 +- .../commonizer/cir/impl/RecursionMarkers.kt | 2 + .../commonizer/core/AnnotationsCommonizer.kt | 22 +++--- .../core/CallableValueParametersCommonizer.kt | 3 +- .../commonizer/core/ClassCommonizer.kt | 3 +- .../commonizer/core/CommonizationVisitor.kt | 13 ++-- .../commonizer/core/TypeAliasCommonizer.kt | 3 +- .../descriptors/commonizer/utils/misc.kt | 76 ++++++++++++++++++- prepare/compiler/compiler.pro | 7 ++ 26 files changed, 227 insertions(+), 125 deletions(-) diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedAnnotationDescriptor.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedAnnotationDescriptor.kt index 5ce070970d3..e3f01500670 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedAnnotationDescriptor.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedAnnotationDescriptor.kt @@ -8,7 +8,8 @@ package org.jetbrains.kotlin.descriptors.commonizer.builder import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation -import org.jetbrains.kotlin.descriptors.commonizer.utils.concat +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactConcat +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapValues import org.jetbrains.kotlin.resolve.constants.AnnotationValue import org.jetbrains.kotlin.storage.getValue @@ -21,7 +22,7 @@ class CommonizedAnnotationDescriptor( } override val allValueArguments by targetComponents.storageManager.createLazyValue { - cirAnnotation.constantValueArguments concat cirAnnotation.annotationValueArguments.mapValues { (_, nestedCirAnnotation) -> + cirAnnotation.constantValueArguments compactConcat cirAnnotation.annotationValueArguments.compactMapValues { (_, nestedCirAnnotation) -> AnnotationValue(CommonizedAnnotationDescriptor(targetComponents, nestedCirAnnotation)) } } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedTypeParameterDescriptor.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedTypeParameterDescriptor.kt index 1ca2df9e0e3..41afa3f784b 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedTypeParameterDescriptor.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedTypeParameterDescriptor.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.SupertypeLoopChecker import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.KotlinType @@ -40,7 +41,7 @@ class CommonizedTypeParameterDescriptor( return if (cirUpperBounds.isEmpty()) listOf(targetComponents.builtIns.defaultBound) else - cirUpperBounds.map { it.buildType(targetComponents, typeParameterResolver) } + cirUpperBounds.compactMap { it.buildType(targetComponents, typeParameterResolver) } } override fun reportSupertypeLoopError(type: KotlinType) = diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/builderUtils.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/builderUtils.kt index 5038e4d54df..a5ca5b6a189 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/builderUtils.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/builderUtils.kt @@ -8,6 +8,9 @@ package org.jetbrains.kotlin.descriptors.commonizer.builder import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.commonizer.cir.* +import org.jetbrains.kotlin.descriptors.commonizer.utils.compact +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapIndexed import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.resolve.DescriptorFactory import org.jetbrains.kotlin.resolve.DescriptorUtils @@ -21,7 +24,7 @@ internal fun List.buildDescriptorsAndTypeParameterResolver( containingDeclaration: DeclarationDescriptor, typeParametersIndexOffset: Int = 0 ): Pair, TypeParameterResolver> { - val ownTypeParameters = mutableListOf() + val ownTypeParameters = ArrayList(size) val typeParameterResolver = TypeParameterResolverImpl( ownTypeParameters = ownTypeParameters, @@ -49,7 +52,7 @@ internal fun List.buildDescriptors( targetComponents: TargetDeclarationsBuilderComponents, typeParameterResolver: TypeParameterResolver, containingDeclaration: CallableDescriptor -): List = mapIndexed { index, param -> +): List = compactMapIndexed { index, param -> ValueParameterDescriptorImpl( containingDeclaration, null, @@ -66,10 +69,7 @@ internal fun List.buildDescriptors( } internal fun List.buildDescriptors(targetComponents: TargetDeclarationsBuilderComponents): Annotations = - if (isEmpty()) - Annotations.EMPTY - else - Annotations.create(map { CommonizedAnnotationDescriptor(targetComponents, it) }) + Annotations.create(compactMap { CommonizedAnnotationDescriptor(targetComponents, it) }) internal fun CirExtensionReceiver.buildExtensionReceiver( targetComponents: TargetDeclarationsBuilderComponents, @@ -108,7 +108,7 @@ internal fun CirSimpleType.buildType( ) is CirTypeAliasType -> { val typeAliasDescriptor = targetComponents.findClassOrTypeAlias(classifierId).checkClassifierType() - val arguments = this.arguments.map { it.buildArgument(targetComponents, typeParameterResolver, expandTypeAliases) } + val arguments = this.arguments.compactMap { it.buildArgument(targetComponents, typeParameterResolver, expandTypeAliases) } if (expandTypeAliases) buildExpandedType(typeAliasDescriptor, arguments, isMarkedNullable) @@ -152,7 +152,7 @@ private fun CirClassType.collectArguments( expandTypeAliases: Boolean ): List { return if (outerType == null) { - arguments.map { it.buildArgument(targetComponents, typeParameterResolver, expandTypeAliases) } + arguments.compactMap { it.buildArgument(targetComponents, typeParameterResolver, expandTypeAliases) } } else { val allTypes = generateSequence(this) { it.outerType }.toList() val arguments = mutableListOf() @@ -161,7 +161,7 @@ private fun CirClassType.collectArguments( allTypes[index].arguments.mapTo(arguments) { it.buildArgument(targetComponents, typeParameterResolver, expandTypeAliases) } } - arguments.toList() + arguments.compact() } } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirClass.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirClass.kt index 3cbf040122f..e9be4f7c01d 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirClass.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirClass.kt @@ -16,5 +16,7 @@ interface CirClass : CirClassifier, CirHasModality { val isInline: Boolean val isInner: Boolean val isExternal: Boolean - val supertypes: MutableCollection + val supertypes: Collection + + fun setSupertypes(supertypes: Collection) } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirAnnotationFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirAnnotationFactory.kt index 560f1118b40..4bf9a745fb9 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirAnnotationFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirAnnotationFactory.kt @@ -10,8 +10,9 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassType import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirAnnotationImpl -import org.jetbrains.kotlin.descriptors.commonizer.utils.Interner +import org.jetbrains.kotlin.descriptors.commonizer.utils.* import org.jetbrains.kotlin.descriptors.commonizer.utils.checkConstantSupportedInCommonization +import org.jetbrains.kotlin.descriptors.commonizer.utils.compact import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.constants.AnnotationValue @@ -27,8 +28,8 @@ object CirAnnotationFactory { if (allValueArguments.isEmpty()) return create(type = type, constantValueArguments = emptyMap(), annotationValueArguments = emptyMap()) - val constantValueArguments: MutableMap> = THashMap() - val annotationValueArguments: MutableMap = THashMap() + val constantValueArguments: MutableMap> = THashMap(allValueArguments.size) + val annotationValueArguments: MutableMap = THashMap(allValueArguments.size) allValueArguments.forEach { (name, constantValue) -> checkConstantSupportedInCommonization( @@ -46,8 +47,8 @@ object CirAnnotationFactory { return create( type = type, - constantValueArguments = constantValueArguments, - annotationValueArguments = annotationValueArguments + constantValueArguments = constantValueArguments.compact(), + annotationValueArguments = annotationValueArguments.compact() ) } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassConstructorFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassConstructorFactory.kt index 7d0e19e9e37..b9445dc44ad 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassConstructorFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassConstructorFactory.kt @@ -10,6 +10,8 @@ import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor import org.jetbrains.kotlin.descriptors.DescriptorVisibility import org.jetbrains.kotlin.descriptors.commonizer.cir.* import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirClassConstructorImpl +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapNotNull object CirClassConstructorFactory { fun create(source: ClassConstructorDescriptor): CirClassConstructor { @@ -18,14 +20,14 @@ object CirClassConstructorFactory { } return create( - annotations = source.annotations.map(CirAnnotationFactory::create), - typeParameters = source.typeParameters.mapNotNull { typeParameter -> + annotations = source.annotations.compactMap(CirAnnotationFactory::create), + typeParameters = source.typeParameters.compactMapNotNull { typeParameter -> // save only type parameters that are contributed by the constructor itself typeParameter.takeIf { it.containingDeclaration == source }?.let(CirTypeParameterFactory::create) }, visibility = source.visibility, containingClassDetails = CirContainingClassDetailsFactory.create(source), - valueParameters = source.valueParameters.map(CirValueParameterFactory::create), + valueParameters = source.valueParameters.compactMap(CirValueParameterFactory::create), hasStableParameterNames = source.hasStableParameterNames(), isPrimary = source.isPrimary ) diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassFactory.kt index 92459040e7c..51757cf2e5f 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirClassFactory.kt @@ -11,17 +11,17 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.DescriptorVisibility import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClass -import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeParameter import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirClassImpl +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name object CirClassFactory { fun create(source: ClassDescriptor): CirClass = create( - annotations = source.annotations.map(CirAnnotationFactory::create), + annotations = source.annotations.compactMap(CirAnnotationFactory::create), name = source.name.intern(), - typeParameters = source.declaredTypeParameters.map(CirTypeParameterFactory::create), + typeParameters = source.declaredTypeParameters.compactMap(CirTypeParameterFactory::create), visibility = source.visibility, modality = source.modality, kind = source.kind, @@ -30,25 +30,25 @@ object CirClassFactory { isData = source.isData, isInline = source.isInline, isInner = source.isInner, - isExternal = source.isExternal, - supertypes = source.typeConstructor.supertypes.mapTo(mutableListOf()) { CirTypeFactory.create(it) } - ) + isExternal = source.isExternal + ).apply { + setSupertypes(source.typeConstructor.supertypes.compactMap { CirTypeFactory.create(it) }) + } @Suppress("NOTHING_TO_INLINE") inline fun create( - annotations: List, - name: Name, - typeParameters: List, - visibility: DescriptorVisibility, - modality: Modality, - kind: ClassKind, - companion: Name?, - isCompanion: Boolean, - isData: Boolean, - isInline: Boolean, - isInner: Boolean, - isExternal: Boolean, - supertypes: MutableCollection + annotations: List, + name: Name, + typeParameters: List, + visibility: DescriptorVisibility, + modality: Modality, + kind: ClassKind, + companion: Name?, + isCompanion: Boolean, + isData: Boolean, + isInline: Boolean, + isInner: Boolean, + isExternal: Boolean ): CirClass { return CirClassImpl( annotations = annotations, @@ -62,8 +62,7 @@ object CirClassFactory { isData = isData, isInline = isInline, isInner = isInner, - isExternal = isExternal, - supertypes = supertypes + isExternal = isExternal ) } } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirExtensionReceiverFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirExtensionReceiverFactory.kt index 2fe81210572..c8ae23fac71 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirExtensionReceiverFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirExtensionReceiverFactory.kt @@ -10,10 +10,11 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation import org.jetbrains.kotlin.descriptors.commonizer.cir.CirExtensionReceiver import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirExtensionReceiverImpl +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap object CirExtensionReceiverFactory { fun create(source: ReceiverParameterDescriptor): CirExtensionReceiver = create( - annotations = source.annotations.map(CirAnnotationFactory::create), + annotations = source.annotations.compactMap(CirAnnotationFactory::create), type = CirTypeFactory.create(source.type) ) diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirFunctionFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirFunctionFactory.kt index 5f349d4124c..ff0f5331d16 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirFunctionFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirFunctionFactory.kt @@ -8,18 +8,19 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir.factory import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.commonizer.cir.* import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirFunctionImpl +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name object CirFunctionFactory { fun create(source: SimpleFunctionDescriptor): CirFunction = create( - annotations = source.annotations.map(CirAnnotationFactory::create), + annotations = source.annotations.compactMap(CirAnnotationFactory::create), name = source.name.intern(), - typeParameters = source.typeParameters.map(CirTypeParameterFactory::create), + typeParameters = source.typeParameters.compactMap(CirTypeParameterFactory::create), visibility = source.visibility, modality = source.modality, containingClassDetails = CirContainingClassDetailsFactory.create(source), - valueParameters = source.valueParameters.map(CirValueParameterFactory::create), + valueParameters = source.valueParameters.compactMap(CirValueParameterFactory::create), hasStableParameterNames = source.hasStableParameterNames(), extensionReceiver = source.extensionReceiverParameter?.let(CirExtensionReceiverFactory::create), returnType = CirTypeFactory.create(source.returnType!!), @@ -29,18 +30,18 @@ object CirFunctionFactory { @Suppress("NOTHING_TO_INLINE") inline fun create( - annotations: List, - name: Name, - typeParameters: List, - visibility: DescriptorVisibility, - modality: Modality, - containingClassDetails: CirContainingClassDetails?, - valueParameters: List, - hasStableParameterNames: Boolean, - extensionReceiver: CirExtensionReceiver?, - returnType: CirType, - kind: CallableMemberDescriptor.Kind, - modifiers: CirFunctionModifiers + annotations: List, + name: Name, + typeParameters: List, + visibility: DescriptorVisibility, + modality: Modality, + containingClassDetails: CirContainingClassDetails?, + valueParameters: List, + hasStableParameterNames: Boolean, + extensionReceiver: CirExtensionReceiver?, + returnType: CirType, + kind: CallableMemberDescriptor.Kind, + modifiers: CirFunctionModifiers ): CirFunction { return CirFunctionImpl( annotations = annotations, diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyFactory.kt index a871ea56abb..c806528394e 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyFactory.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.descriptors.DescriptorVisibility import org.jetbrains.kotlin.descriptors.commonizer.cir.* import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirPropertyImpl import org.jetbrains.kotlin.descriptors.commonizer.utils.checkConstantSupportedInCommonization +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.constants.ConstantValue @@ -28,9 +29,9 @@ object CirPropertyFactory { } return create( - annotations = source.annotations.map(CirAnnotationFactory::create), + annotations = source.annotations.compactMap(CirAnnotationFactory::create), name = source.name.intern(), - typeParameters = source.typeParameters.map(CirTypeParameterFactory::create), + typeParameters = source.typeParameters.compactMap(CirTypeParameterFactory::create), visibility = source.visibility, modality = source.modality, containingClassDetails = CirContainingClassDetailsFactory.create(source), @@ -44,33 +45,33 @@ object CirPropertyFactory { isDelegate = source.isDelegated, getter = source.getter?.let(CirPropertyGetterFactory::create), setter = source.setter?.let(CirPropertySetterFactory::create), - backingFieldAnnotations = source.backingField?.annotations?.map(CirAnnotationFactory::create), - delegateFieldAnnotations = source.delegateField?.annotations?.map(CirAnnotationFactory::create), + backingFieldAnnotations = source.backingField?.annotations?.compactMap(CirAnnotationFactory::create), + delegateFieldAnnotations = source.delegateField?.annotations?.compactMap(CirAnnotationFactory::create), compileTimeInitializer = source.compileTimeInitializer ) } @Suppress("NOTHING_TO_INLINE") inline fun create( - annotations: List, - name: Name, - typeParameters: List, - visibility: DescriptorVisibility, - modality: Modality, - containingClassDetails: CirContainingClassDetails?, - isExternal: Boolean, - extensionReceiver: CirExtensionReceiver?, - returnType: CirType, - kind: CallableMemberDescriptor.Kind, - isVar: Boolean, - isLateInit: Boolean, - isConst: Boolean, - isDelegate: Boolean, - getter: CirPropertyGetter?, - setter: CirPropertySetter?, - backingFieldAnnotations: List?, - delegateFieldAnnotations: List?, - compileTimeInitializer: ConstantValue<*>? + annotations: List, + name: Name, + typeParameters: List, + visibility: DescriptorVisibility, + modality: Modality, + containingClassDetails: CirContainingClassDetails?, + isExternal: Boolean, + extensionReceiver: CirExtensionReceiver?, + returnType: CirType, + kind: CallableMemberDescriptor.Kind, + isVar: Boolean, + isLateInit: Boolean, + isConst: Boolean, + isDelegate: Boolean, + getter: CirPropertyGetter?, + setter: CirPropertySetter?, + backingFieldAnnotations: List?, + delegateFieldAnnotations: List?, + compileTimeInitializer: ConstantValue<*>? ): CirProperty { return CirPropertyImpl( annotations = annotations, diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyGetterFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyGetterFactory.kt index e373cbe504e..0ffd7ede42a 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyGetterFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertyGetterFactory.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation import org.jetbrains.kotlin.descriptors.commonizer.cir.CirPropertyGetter import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirPropertyGetterImpl import org.jetbrains.kotlin.descriptors.commonizer.utils.Interner +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap object CirPropertyGetterFactory { private val interner = Interner() @@ -27,7 +28,7 @@ object CirPropertyGetterFactory { DEFAULT_NO_ANNOTATIONS else create( - annotations = source.annotations.map(CirAnnotationFactory::create), + annotations = source.annotations.compactMap(CirAnnotationFactory::create), isDefault = source.isDefault, isExternal = source.isExternal, isInline = source.isInline diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertySetterFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertySetterFactory.kt index fad47cc88ac..faa47c53241 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertySetterFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirPropertySetterFactory.kt @@ -12,13 +12,14 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation import org.jetbrains.kotlin.descriptors.commonizer.cir.CirPropertySetter import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirPropertySetterImpl import org.jetbrains.kotlin.descriptors.commonizer.utils.Interner +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap object CirPropertySetterFactory { private val interner = Interner() fun create(source: PropertySetterDescriptor): CirPropertySetter = create( - annotations = source.annotations.map(CirAnnotationFactory::create), - parameterAnnotations = source.valueParameters[0].annotations.map(CirAnnotationFactory::create), + annotations = source.annotations.compactMap(CirAnnotationFactory::create), + parameterAnnotations = source.valueParameters[0].annotations.compactMap(CirAnnotationFactory::create), visibility = source.visibility, isDefault = source.isDefault, isExternal = source.isExternal, @@ -26,12 +27,12 @@ object CirPropertySetterFactory { ) fun create( - annotations: List, - parameterAnnotations: List, - visibility: DescriptorVisibility, - isDefault: Boolean, - isExternal: Boolean, - isInline: Boolean + annotations: List, + parameterAnnotations: List, + visibility: DescriptorVisibility, + isDefault: Boolean, + isExternal: Boolean, + isInline: Boolean ): CirPropertySetter { return interner.intern( CirPropertySetterImpl( diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeAliasFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeAliasFactory.kt index 01ff9904709..bb4c3716fdb 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeAliasFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeAliasFactory.kt @@ -9,14 +9,15 @@ import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor import org.jetbrains.kotlin.descriptors.DescriptorVisibility import org.jetbrains.kotlin.descriptors.commonizer.cir.* import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirTypeAliasImpl +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name object CirTypeAliasFactory { fun create(source: TypeAliasDescriptor): CirTypeAlias = create( - annotations = source.annotations.map(CirAnnotationFactory::create), + annotations = source.annotations.compactMap(CirAnnotationFactory::create), name = source.name.intern(), - typeParameters = source.declaredTypeParameters.map(CirTypeParameterFactory::create), + typeParameters = source.declaredTypeParameters.compactMap(CirTypeParameterFactory::create), visibility = source.visibility, underlyingType = CirTypeFactory.create(source.underlyingType, useAbbreviation = true) as CirClassOrTypeAliasType, expandedType = CirTypeFactory.create(source.expandedType, useAbbreviation = false) as CirClassType diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeFactory.kt index 418b4991e6f..899c1eed888 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeFactory.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.commonizer.cir.* import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirClassTypeImpl import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirTypeAliasTypeImpl -import org.jetbrains.kotlin.descriptors.commonizer.utils.Interner +import org.jetbrains.kotlin.descriptors.commonizer.utils.* import org.jetbrains.kotlin.descriptors.commonizer.utils.declarationDescriptor import org.jetbrains.kotlin.descriptors.commonizer.utils.extractExpandedType import org.jetbrains.kotlin.descriptors.commonizer.utils.internedClassId @@ -147,7 +147,7 @@ object CirTypeFactory { @Suppress("NOTHING_TO_INLINE") private inline fun createArguments(arguments: List, useAbbreviation: Boolean): List = - arguments.map { projection -> + arguments.compactMap { projection -> if (projection.isStarProjection) CirStarTypeProjection else diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeParameterFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeParameterFactory.kt index a0cb0db9d7d..e52130ac410 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeParameterFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirTypeParameterFactory.kt @@ -10,17 +10,18 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeParameter import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirTypeParameterImpl +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance object CirTypeParameterFactory { fun create(source: TypeParameterDescriptor): CirTypeParameter = create( - annotations = source.annotations.map(CirAnnotationFactory::create), + annotations = source.annotations.compactMap(CirAnnotationFactory::create), name = source.name.intern(), isReified = source.isReified, variance = source.variance, - upperBounds = source.upperBounds.map(CirTypeFactory::create) + upperBounds = source.upperBounds.compactMap(CirTypeFactory::create) ) @Suppress("NOTHING_TO_INLINE") diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirValueParameterFactory.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirValueParameterFactory.kt index 11204f98c21..165e7df9e20 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirValueParameterFactory.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirValueParameterFactory.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType import org.jetbrains.kotlin.descriptors.commonizer.cir.CirValueParameter import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirValueParameterImpl import org.jetbrains.kotlin.descriptors.commonizer.utils.Interner +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.name.Name @@ -18,7 +19,7 @@ object CirValueParameterFactory { private val interner = Interner() fun create(source: ValueParameterDescriptor): CirValueParameter = create( - annotations = source.annotations.map(CirAnnotationFactory::create), + annotations = source.annotations.compactMap(CirAnnotationFactory::create), name = source.name.intern(), returnType = CirTypeFactory.create(source.returnType!!), varargElementType = source.varargElementType?.let(CirTypeFactory::create), diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirClassImpl.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirClassImpl.kt index 101a98b69ac..49dd69552ad 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirClassImpl.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirClassImpl.kt @@ -27,5 +27,14 @@ data class CirClassImpl( override val isInline: Boolean, override val isInner: Boolean, override val isExternal: Boolean, - override val supertypes: MutableCollection -) : CirClass +) : CirClass { + private var _supertypes: Collection? = null + + override val supertypes: Collection + get() = _supertypes.orEmpty() + + override fun setSupertypes(supertypes: Collection) { + check(_supertypes == null) + _supertypes = supertypes + } +} diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirDeclarationImpl.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirDeclarationImpl.kt index 4d436795730..d0f9b00d659 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirDeclarationImpl.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirDeclarationImpl.kt @@ -8,4 +8,4 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir.impl import org.jetbrains.kotlin.descriptors.commonizer.cir.CirDeclaration @Suppress("unused", "NOTHING_TO_INLINE") -internal inline fun CirDeclaration.unsupported(): Nothing = error("This method should never be called") +internal inline fun CirDeclaration.unsupported(): Nothing = error("This method should never be called on ${this::class.java}, $this") diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/RecursionMarkers.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/RecursionMarkers.kt index 11bc1035935..20648badf71 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/RecursionMarkers.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/RecursionMarkers.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir.impl import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClass import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassifier import org.jetbrains.kotlin.descriptors.commonizer.cir.CirRecursionMarker +import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType import org.jetbrains.kotlin.name.Name object CirClassRecursionMarker : CirClass, CirRecursionMarker { @@ -26,6 +27,7 @@ object CirClassRecursionMarker : CirClass, CirRecursionMarker { override val isInner get() = unsupported() override val isExternal get() = unsupported() override val supertypes get() = unsupported() + override fun setSupertypes(supertypes: Collection) = unsupported() } object CirClassifierRecursionMarker : CirClassifier, CirRecursionMarker { diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizer.kt index 9c998441783..747560f9224 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/AnnotationsCommonizer.kt @@ -11,6 +11,8 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirAnnotationFact import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory import org.jetbrains.kotlin.descriptors.commonizer.core.AnnotationsCommonizer.Companion.FALLBACK_MESSAGE import org.jetbrains.kotlin.descriptors.commonizer.utils.DEPRECATED_ANNOTATION_CID +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapOf import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.descriptors.commonizer.utils.internedClassId import org.jetbrains.kotlin.name.ClassId @@ -62,18 +64,18 @@ private class DeprecatedAnnotationCommonizer : Commonizer> = if (level == WARNING) { // don't populate with the default level value - mapOf(PROPERTY_NAME_MESSAGE to messageValue) + compactMapOf(PROPERTY_NAME_MESSAGE, messageValue) } else - hashMapOf( - PROPERTY_NAME_MESSAGE to messageValue, - PROPERTY_NAME_LEVEL to level.toDeprecationLevelValue() + compactMapOf( + PROPERTY_NAME_MESSAGE, messageValue, + PROPERTY_NAME_LEVEL, level.toDeprecationLevelValue() ) val annotationValueArguments: Map = if (replaceWithExpression.isEmpty() && replaceWithImports.isEmpty()) { // don't populate with empty (default) ReplaceWith emptyMap() } else - mapOf(PROPERTY_NAME_REPLACE_WITH to replaceWithExpression.toReplaceWithValue(replaceWithImports)) + compactMapOf(PROPERTY_NAME_REPLACE_WITH, replaceWithExpression.toReplaceWithValue(replaceWithImports)) return CirAnnotationFactory.create( type = DEPRECATED_ANNOTATION_TYPE, @@ -205,7 +207,7 @@ private class DeprecatedAnnotationCommonizer : Commonizer> = (this[name] as? ArrayValue)?.value ?: return null if (elements.isEmpty()) return emptyList() - val result = mutableListOf() + val result = ArrayList(elements.size) for (element in elements) { if (element is StringValue) { result += element.value @@ -219,10 +221,10 @@ private class DeprecatedAnnotationCommonizer : Commonizer): CirAnnotation = CirAnnotationFactory.create( type = REPLACE_WITH_ANNOTATION_TYPE, - constantValueArguments = mapOf( - PROPERTY_NAME_EXPRESSION to StringValue(expression), - PROPERTY_NAME_IMPORTS to ArrayValue( - value = imports.map { StringValue(it) }, + constantValueArguments = compactMapOf( + PROPERTY_NAME_EXPRESSION, StringValue(expression), + PROPERTY_NAME_IMPORTS, ArrayValue( + value = imports.compactMap { StringValue(it) }, computeType = { it.builtIns.getArrayElementType(it.builtIns.stringType) } ) ), diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CallableValueParametersCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CallableValueParametersCommonizer.kt index 346ab0de90f..f172172befe 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CallableValueParametersCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CallableValueParametersCommonizer.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirValueParameter import org.jetbrains.kotlin.descriptors.commonizer.core.CallableValueParametersCommonizer.CallableToPatch.Companion.doNothing import org.jetbrains.kotlin.descriptors.commonizer.core.CallableValueParametersCommonizer.CallableToPatch.Companion.patchCallables import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache +import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapIndexed import org.jetbrains.kotlin.descriptors.commonizer.utils.intern import org.jetbrains.kotlin.descriptors.commonizer.utils.isObjCInteropCallableAnnotation import org.jetbrains.kotlin.name.Name @@ -48,7 +49,7 @@ class CallableValueParametersCommonizer( callablesToPatch.forEach { callableToPatch -> val callable = callableToPatch.callable callable.hasStableParameterNames = false - callable.valueParameters = callable.valueParameters.mapIndexed { index, valueParameter -> + callable.valueParameters = callable.valueParameters.compactMapIndexed { index, valueParameter -> val newName = newNames[index] if (valueParameter.name != newName) { CirValueParameterFactory.create( diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassCommonizer.kt index bb9078c06a3..2030d50752f 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ClassCommonizer.kt @@ -33,8 +33,7 @@ class ClassCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer>?) { - supertypesMap ?: return - for ((_, supertypesGroup) in supertypesMap) { - val commonSupertype = commonize(supertypesGroup, TypeCommonizer(root.cache)) - if (commonSupertype != null) - supertypes.add(commonSupertype) - } + setSupertypes( + if (supertypesMap.isNullOrEmpty()) + emptyList() + else + supertypesMap.values.compactMapNotNull { supertypesGroup -> commonize(supertypesGroup, TypeCommonizer(root.cache)) } + ) } } diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeAliasCommonizer.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeAliasCommonizer.kt index 59719e19ca7..dcbe9bd1c50 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeAliasCommonizer.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeAliasCommonizer.kt @@ -138,8 +138,7 @@ private class TypeAliasExpectClassCommonizer : AbstractStandardCommonizer Sequence.toList(expectedCapacity: Int): List { val result = ArrayList(expectedCapacity) @@ -14,16 +21,77 @@ internal fun Sequence.toList(expectedCapacity: Int): List { return result } -internal infix fun Map.concat(other: Map): Map = +internal infix fun Map.compactConcat(other: Map): Map = when { isEmpty() -> other other.isEmpty() -> this - else -> THashMap(size + other.size, 1F).apply { - putAll(this@concat) - putAll(other) + else -> when (val capacity = size + other.size) { + 0, 1 -> error("Unreachable code") + 2, 3 -> SmartFMap.emptyMap().plusAll(this).plusAll(other) + else -> THashMap(capacity).also { it.putAll(this); it.putAll(other) } } } +internal inline fun Map.compactMapValues(transform: (Map.Entry) -> R): Map = + when (size) { + 0 -> emptyMap() + 1 -> with(entries.iterator().next()) { singletonMap(key, transform(this)) } + 2, 3 -> entries.fold(SmartFMap.emptyMap()) { acc, entry -> acc.plus(entry.key, transform(entry)) } + else -> mapValuesTo(THashMap(size), transform) + } + +internal inline fun Collection.compactMap(transform: (T) -> R): List = + when (size) { + 0 -> emptyList() + 1 -> singletonList(transform(if (this is List) this[0] else iterator().next())) + else -> mapTo(ArrayList(size), transform) + } + +internal inline fun Collection.compactMapNotNull(transform: (T) -> R?): List = + if (isEmpty()) emptyList() else mapNotNullTo(ArrayList(size), transform).compact() + +internal inline fun Collection.compactMapIndexed(transform: (index: Int, T) -> R): List = + when (size) { + 0 -> emptyList() + 1 -> singletonList(transform(0, if (this is List) this[0] else iterator().next())) + else -> mapIndexedTo(ArrayList(size), transform) + } + +internal inline fun List.compact(): List = + when (size) { + 0 -> emptyList() + 1 -> singletonList(this[0]) + else -> when (this) { + is java.util.ArrayList -> { + trimToSize() + this + } + else -> { + @Suppress("ReplaceJavaStaticMethodWithKotlinAnalog") + Arrays.asList(*toTypedArray()) + } + } + } + +internal inline fun Annotations.compactMap(transform: (AnnotationDescriptor) -> R): List = + if (isEmpty()) emptyList() else map(transform).compact() + +internal fun Map.compact(): Map = + when (size) { + 0 -> emptyMap() + 1 -> with(entries.iterator().next()) { singletonMap(key, value) } + 2, 3 -> SmartFMap.emptyMap().plusAll(this) + else -> THashMap(this) + } + +@Suppress("NOTHING_TO_INLINE") +internal inline fun compactMapOf(key: K, value: V): Map = + singletonMap(key, value) + +@Suppress("NOTHING_TO_INLINE") +internal inline fun compactMapOf(key1: K, value1: V, key2: K, value2: V): Map = + SmartFMap.emptyMap().plus(key1, value1).plus(key2, value2) + internal inline fun Iterable.firstNonNull() = firstIsInstance() internal fun Any?.isNull(): Boolean = this == null diff --git a/prepare/compiler/compiler.pro b/prepare/compiler/compiler.pro index f222854d398..e722ff84f68 100644 --- a/prepare/compiler/compiler.pro +++ b/prepare/compiler/compiler.pro @@ -269,3 +269,10 @@ } -dontwarn org.jetbrains.kotlin.fir.** + +# used in commonizer +-keep class com.intellij.util.SmartFMap { + public static ** emptyMap(); + public ** plus(java.lang.Object, java.lang.Object); + public ** plusAll(java.util.Map); +}