From 54befa769f2348891f95b18326fc0ca36b4fdd1a Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 30 Mar 2021 18:16:37 +0200 Subject: [PATCH] IR: add IrClass.getInlineClassRepresentation, serialize/deserialize it The change in FirDeclarationUtil is needed because in case of unsigned types loaded from the standard library, the primary constructor for some reason is not the first, but the second in the list of constructors. --- .../fir/serialization/FirElementSerializer.kt | 16 + .../kotlin/fir/backend/ConversionUtils.kt | 12 + .../fir/backend/Fir2IrClassifierStorage.kt | 5 + .../kotlin/fir/lazy/Fir2IrLazyClass.kt | 8 + .../fir/declarations/InlineClassesUtils.kt | 10 +- .../fir/declarations/FirDeclarationUtil.kt | 2 +- .../kotlin/backend/jvm/JvmSymbols.kt | 6 +- .../psi2ir/generators/ClassGenerator.kt | 6 + .../StandaloneDeclarationGenerator.kt | 7 +- .../ir/declarations/impl/IrClassImpl.kt | 3 + .../persistent/PersistentIrClass.kt | 13 + .../persistent/carriers/ClassCarrier.kt | 9 +- .../ir/serialization/IrCarrierDeserializer.kt | 8 +- .../ir/serialization/IrCarrierSerializer.kt | 6 + .../kotlin/ir/persistentIrGenerator/Class.kt | 10 +- .../PersistentIrGenerator.kt | 10 +- .../IrCarrierDeserializerImpl.kt | 11 +- .../serialization/IrCarrierSerializerImpl.kt | 10 +- .../kotlin/ir/declarations/IrClass.kt | 8 +- .../ir/declarations/lazy/IrLazyClass.kt | 8 + .../ir/util/DeepCopyIrTreeWithSymbols.kt | 2 + .../serialization.common/src/KotlinIr.proto | 8 +- .../src/KotlinPirCarriers.proto | 3 +- .../IrDeclarationDeserializer.kt | 31 +- .../common/serialization/IrFileSerializer.kt | 20 +- .../common/serialization/proto/IrClass.java | 117 +++++ .../serialization/proto/IrClassOrBuilder.java | 9 + .../proto/IrInlineClassRepresentation.java | 428 ++++++++++++++++++ .../IrInlineClassRepresentationOrBuilder.java | 27 ++ .../serialization/proto/PirClassCarrier.java | 151 +++++- .../proto/PirClassCarrierOrBuilder.java | 13 +- ...PirInlineClassRepresentationOrBuilder.java | 27 ++ .../descriptors/InlineClassRepresentation.kt | 5 +- 33 files changed, 950 insertions(+), 59 deletions(-) create mode 100644 compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrInlineClassRepresentation.java create mode 100644 compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrInlineClassRepresentationOrBuilder.java create mode 100644 compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirInlineClassRepresentationOrBuilder.java diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt index f61f4679eeb..595b0b97c23 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt +++ b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt @@ -182,6 +182,22 @@ class FirElementSerializer private constructor( builder.typeTable = typeTableProto } + val representation = (klass as? FirRegularClass)?.getInlineClassUnderlyingParameter() + if (representation != null) { + builder.inlineClassUnderlyingPropertyName = getSimpleNameIndex(representation.name) + + val property = callableMembers.single { + it is FirProperty && it.receiverTypeRef == null && it.name == representation.name + } + if (!property.visibility.isPublicAPI) { + if (useTypeTable()) { + builder.inlineClassUnderlyingTypeId = typeId(representation.returnTypeRef) + } else { + builder.setInlineClassUnderlyingType(typeProto(representation.returnTypeRef)) + } + } + } + if (versionRequirementTable == null) error("Version requirements must be serialized for classes: ${klass.render()}") builder.addAllVersionRequirement(versionRequirementTable.serializeVersionRequirements(klass)) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt index 2b56e3458d9..7c5025e05df 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.backend import com.intellij.psi.PsiCompiledElement import org.jetbrains.kotlin.KtNodeTypes import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.InlineClassRepresentation import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.fir.* @@ -497,3 +498,14 @@ fun Fir2IrComponents.createTemporaryVariableForSafeCallConstruction( conversionScope: Fir2IrConversionScope ): Pair = createTemporaryVariable(receiverExpression, conversionScope, "safe_receiver") + +// TODO: implement inlineClassRepresentation in FirRegularClass instead. +fun Fir2IrComponents.computeInlineClassRepresentation(klass: FirRegularClass): InlineClassRepresentation? { + if (!klass.isInline) return null + val parameter = klass.getInlineClassUnderlyingParameter() ?: error("Inline class has no underlying parameter: ${klass.render()}") + val underlyingType = parameter.returnTypeRef.toIrType(typeConverter) + return InlineClassRepresentation( + parameter.name, + underlyingType as? IrSimpleType ?: error("Inline class underlying type is not a simple type: ${klass.render()}") + ) +} diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt index db4b7e1bb96..210150ce9a4 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt @@ -127,6 +127,10 @@ class Fir2IrClassifierStorage( superTypes = klass.superTypeRefs.map { superTypeRef -> superTypeRef.toIrType() } } + private fun IrClass.declareInlineClassRepresentation(klass: FirRegularClass) { + inlineClassRepresentation = computeInlineClassRepresentation(klass) + } + private fun IrClass.declareSupertypesAndTypeParameters(klass: FirClass<*>): IrClass { declareTypeParameters(klass) declareSupertypes(klass) @@ -175,6 +179,7 @@ class Fir2IrClassifierStorage( irClass.declareTypeParameters(regularClass) irClass.setThisReceiver(regularClass.typeParameters) irClass.declareSupertypes(regularClass) + irClass.declareInlineClassRepresentation(regularClass) return irClass } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt index db8b8979432..41c89f40165 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.lazy import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.fir.backend.Fir2IrComponents +import org.jetbrains.kotlin.fir.backend.computeInlineClassRepresentation import org.jetbrains.kotlin.fir.backend.declareThisReceiverParameter import org.jetbrains.kotlin.fir.backend.toIrType import org.jetbrains.kotlin.fir.declarations.* @@ -21,6 +22,7 @@ import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar import org.jetbrains.kotlin.ir.expressions.IrConstructorCall +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl import org.jetbrains.kotlin.ir.util.isFakeOverride @@ -117,6 +119,12 @@ class Fir2IrLazyClass( receiver } + override var inlineClassRepresentation: InlineClassRepresentation? + get() = computeInlineClassRepresentation(fir) + set(_) { + error("Mutating Fir2Ir lazy elements is not possible") + } + private val fakeOverridesByName = mutableMapOf>() fun getFakeOverridesByName(name: Name): Collection = fakeOverridesByName.getOrPut(name) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/InlineClassesUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/InlineClassesUtils.kt index e39b8d6ca9a..887d0fd253a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/InlineClassesUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/InlineClassesUtils.kt @@ -29,9 +29,9 @@ internal fun ConeKotlinType.unsubstitutedUnderlyingTypeForInlineClass(session: F ?.toSymbol(session) as? FirRegularClassSymbol ?: return null symbol.ensureResolved(FirResolvePhase.STATUS, session) - val firClass = symbol.fir - if (!firClass.status.isInline) return null - val constructor = firClass.declarations.singleOrNull { it is FirConstructor && it.isPrimary } as FirConstructor? ?: return null - val valueParameter = constructor.valueParameters.singleOrNull() ?: return null - return valueParameter.returnTypeRef.coneType + return symbol.fir.getInlineClassUnderlyingParameter()?.returnTypeRef?.coneType } + +// TODO: implement inlineClassRepresentation in FirRegularClass instead. +fun FirRegularClass.getInlineClassUnderlyingParameter(): FirValueParameter? = + if (isInline) primaryConstructor?.valueParameters?.singleOrNull() else null diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt index 3d30f2ce0e6..45e0d0589c1 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt @@ -155,7 +155,7 @@ val FirClass<*>.constructorsSortedByDelegation: List get() = constructors.sortedWith(ConstructorDelegationComparator) val FirClass<*>.primaryConstructor: FirConstructor? - get() = constructors.firstOrNull()?.takeIf { it.isPrimary } + get() = constructors.find(FirConstructor::isPrimary) fun FirRegularClass.collectEnumEntries(): Collection { assert(classKind == ClassKind.ENUM_CLASS) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt index c73b7b36347..bba2dbb84a2 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt @@ -15,10 +15,7 @@ import org.jetbrains.kotlin.codegen.coroutines.INVOKE_SUSPEND_METHOD_NAME import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_CALL_RESULT_NAME import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_CREATE_METHOD_NAME -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.descriptors.DescriptorVisibilities -import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.builders.declarations.* import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin @@ -253,6 +250,7 @@ class JvmSymbols( klass.addConstructor { isPrimary = true }.apply { addValueParameter("value", irBuiltIns.anyNType) } + klass.inlineClassRepresentation = InlineClassRepresentation(Name.identifier("value"), irBuiltIns.anyNType as IrSimpleType) } val continuationImplClass: IrClassSymbol = diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt index e5ba8c9f328..8c51b446a9d 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl import org.jetbrains.kotlin.ir.expressions.mapValueParameters import org.jetbrains.kotlin.ir.expressions.putTypeArguments import org.jetbrains.kotlin.ir.expressions.typeParametersCount +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.util.SYNTHETIC_OFFSET import org.jetbrains.kotlin.ir.util.createIrClassFromDescriptor import org.jetbrains.kotlin.ir.util.declareSimpleFunctionWithOverrides @@ -121,6 +122,11 @@ class ClassGenerator( generateFakeOverrideMemberDeclarations(irClass, ktClassOrObject) if (irClass.isInline && ktClassOrObject is KtClassOrObject) { + val representation = classDescriptor.inlineClassRepresentation + ?: error("Unknown representation for inline class: $classDescriptor") + irClass.inlineClassRepresentation = representation.mapUnderlyingType { type -> + type.toIrType() as? IrSimpleType ?: error("Inline class underlying type is not a simple type: $classDescriptor") + } generateAdditionalMembersForInlineClasses(irClass, ktClassOrObject) } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt index 8fb92db2a6c..363b1f84f37 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.symbols.* +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.impl.IrUninitializedType import org.jetbrains.kotlin.ir.util.createIrClassFromDescriptor import org.jetbrains.kotlin.ir.util.withScope @@ -76,7 +77,9 @@ class StandaloneDeclarationGenerator(private val context: GeneratorContext) { } } - fun generateClass(startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: ClassDescriptor, symbol: IrClassSymbol): IrClass { + fun generateClass( + startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: ClassDescriptor, symbol: IrClassSymbol + ): IrClass { val irClass = irFactory.createIrClassFromDescriptor(startOffset, endOffset, origin, symbol, descriptor) symbolTable.withScope(irClass) { @@ -93,6 +96,8 @@ class StandaloneDeclarationGenerator(private val context: GeneratorContext) { descriptor.thisAsReceiverParameter, descriptor.thisAsReceiverParameter.type.toIrType() ).also { it.parent = irClass } + + irClass.inlineClassRepresentation = descriptor.inlineClassRepresentation?.mapUnderlyingType { it.toIrType() as IrSimpleType } } return irClass diff --git a/compiler/ir/ir.tree.impl/src/org/jetbrains/kotlin/ir/declarations/impl/IrClassImpl.kt b/compiler/ir/ir.tree.impl/src/org/jetbrains/kotlin/ir/declarations/impl/IrClassImpl.kt index 2f184aceeff..c6cd8377145 100644 --- a/compiler/ir/ir.tree.impl/src/org/jetbrains/kotlin/ir/declarations/impl/IrClassImpl.kt +++ b/compiler/ir/ir.tree.impl/src/org/jetbrains/kotlin/ir/declarations/impl/IrClassImpl.kt @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.IrConstructorCall import org.jetbrains.kotlin.ir.symbols.IrClassSymbol +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.name.Name @@ -64,6 +65,8 @@ class IrClassImpl( override var superTypes: List = emptyList() + override var inlineClassRepresentation: InlineClassRepresentation? = null + override var metadata: MetadataSource? = null override var attributeOwnerId: IrAttributeContainer = this diff --git a/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/declarations/persistent/PersistentIrClass.kt b/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/declarations/persistent/PersistentIrClass.kt index 9c8dba9aad9..edb8cb8332c 100644 --- a/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/declarations/persistent/PersistentIrClass.kt +++ b/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/declarations/persistent/PersistentIrClass.kt @@ -10,6 +10,7 @@ import java.util.Collections import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.DescriptorVisibility +import org.jetbrains.kotlin.descriptors.InlineClassRepresentation import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI @@ -27,6 +28,7 @@ import org.jetbrains.kotlin.ir.expressions.IrConstructorCall import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.name.Name @@ -157,5 +159,16 @@ internal class PersistentIrClass( } } + override var inlineClassRepresentationField: InlineClassRepresentation? = null + + override var inlineClassRepresentation: InlineClassRepresentation? + get() = getCarrier().inlineClassRepresentationField + set(v) { + if (inlineClassRepresentation !== v) { + setCarrier() + inlineClassRepresentationField = v + } + } + override var attributeOwnerId: IrAttributeContainer = this } diff --git a/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/declarations/persistent/carriers/ClassCarrier.kt b/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/declarations/persistent/carriers/ClassCarrier.kt index 38962c85c3b..f438aa4edb0 100644 --- a/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/declarations/persistent/carriers/ClassCarrier.kt +++ b/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/declarations/persistent/carriers/ClassCarrier.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.ir.declarations.persistent.carriers import org.jetbrains.kotlin.descriptors.DescriptorVisibility +import org.jetbrains.kotlin.descriptors.InlineClassRepresentation import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrTypeParameter @@ -14,6 +15,7 @@ import org.jetbrains.kotlin.ir.expressions.IrConstructorCall import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType // Auto-generated by compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Main.kt. DO NOT EDIT! @@ -26,6 +28,7 @@ internal interface ClassCarrier : DeclarationCarrier{ val typeParametersField: List val typeParametersSymbolField: List val superTypesField: List + val inlineClassRepresentationField: InlineClassRepresentation? override fun clone(): ClassCarrier { return ClassCarrierImpl( @@ -37,7 +40,8 @@ internal interface ClassCarrier : DeclarationCarrier{ visibilityField, modalityField, typeParametersSymbolField, - superTypesField + superTypesField, + inlineClassRepresentationField ) } } @@ -51,7 +55,8 @@ internal class ClassCarrierImpl( override val visibilityField: DescriptorVisibility, override val modalityField: Modality, override val typeParametersSymbolField: List, - override val superTypesField: List + override val superTypesField: List, + override val inlineClassRepresentationField: InlineClassRepresentation? ) : ClassCarrier { override val thisReceiverField: IrValueParameter? diff --git a/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/serialization/IrCarrierDeserializer.kt b/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/serialization/IrCarrierDeserializer.kt index dda04498e60..e7e2e6b6aea 100644 --- a/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/serialization/IrCarrierDeserializer.kt +++ b/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/serialization/IrCarrierDeserializer.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.ir.serialization import org.jetbrains.kotlin.backend.common.serialization.codedInputStream import org.jetbrains.kotlin.backend.common.serialization.proto.IrConstructorCall as ProtoIrConstructorCall +import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation as ProtoIrInlineClassRepresentation import org.jetbrains.kotlin.backend.common.serialization.proto.IrVariable as ProtoIrVariable import org.jetbrains.kotlin.backend.common.serialization.proto.PirAnonymousInitializerCarrier import org.jetbrains.kotlin.backend.common.serialization.proto.PirClassCarrier @@ -21,6 +22,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.PirTypeAliasCarri import org.jetbrains.kotlin.backend.common.serialization.proto.PirTypeParameterCarrier import org.jetbrains.kotlin.backend.common.serialization.proto.PirValueParameterCarrier import org.jetbrains.kotlin.descriptors.DescriptorVisibility +import org.jetbrains.kotlin.descriptors.InlineClassRepresentation import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrVariable @@ -59,6 +61,7 @@ import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite @@ -102,6 +105,8 @@ internal abstract class IrCarrierDeserializer { abstract fun deserializeModality(proto: Long): Modality + abstract fun deserializeInlineClassRepresentation(proto: ProtoIrInlineClassRepresentation): InlineClassRepresentation + abstract fun deserializeIsExternalClass(proto: Long): Boolean abstract fun deserializeIsExternalField(proto: Long): Boolean @@ -132,7 +137,8 @@ internal abstract class IrCarrierDeserializer { deserializeVisibility(proto.flags), deserializeModality(proto.flags), proto.typeParametersList.map { deserializeTypeParameter(it) }, - proto.superTypesList.map { deserializeSuperType(it) } + proto.superTypesList.map { deserializeSuperType(it) }, + if (proto.hasInlineClassRepresentation()) deserializeInlineClassRepresentation(proto.inlineClassRepresentation) else null ) } diff --git a/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/serialization/IrCarrierSerializer.kt b/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/serialization/IrCarrierSerializer.kt index 002b9f16f92..39e05ef83f6 100644 --- a/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/serialization/IrCarrierSerializer.kt +++ b/compiler/ir/ir.tree.persistent/gen/org/jetbrains/kotlin/ir/serialization/IrCarrierSerializer.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.ir.serialization import org.jetbrains.kotlin.backend.common.serialization.proto.IrConstructorCall as ProtoIrConstructorCall +import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation as ProtoIrInlineClassRepresentation import org.jetbrains.kotlin.backend.common.serialization.proto.IrVariable as ProtoIrVariable import org.jetbrains.kotlin.backend.common.serialization.proto.PirAnonymousInitializerCarrier import org.jetbrains.kotlin.backend.common.serialization.proto.PirClassCarrier @@ -20,6 +21,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.PirTypeAliasCarri import org.jetbrains.kotlin.backend.common.serialization.proto.PirTypeParameterCarrier import org.jetbrains.kotlin.backend.common.serialization.proto.PirValueParameterCarrier import org.jetbrains.kotlin.descriptors.DescriptorVisibility +import org.jetbrains.kotlin.descriptors.InlineClassRepresentation import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrVariable @@ -46,6 +48,7 @@ import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType // Auto-generated by compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Main.kt. DO NOT EDIT! @@ -88,6 +91,8 @@ internal abstract class IrCarrierSerializer { abstract fun serializeModality(value: Modality): Long + abstract fun serializeInlineClassRepresentation(value: InlineClassRepresentation): ProtoIrInlineClassRepresentation + abstract fun serializeIsExternalClass(value: Boolean): Long abstract fun serializeIsExternalField(value: Boolean): Long @@ -116,6 +121,7 @@ internal abstract class IrCarrierSerializer { proto.setFlags(serializeVisibility(carrier.visibilityField) or serializeModality(carrier.modalityField)) proto.addAllTypeParameters(carrier.typeParametersSymbolField.map { serializeTypeParameter(it) }) proto.addAllSuperTypes(carrier.superTypesField.map { serializeSuperType(it) }) + carrier.inlineClassRepresentationField?.let { proto.setInlineClassRepresentation(serializeInlineClassRepresentation(it)) } return proto.build().toByteArray() } diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Class.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Class.kt index fb3a24c311c..b5d007aa466 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Class.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Class.kt @@ -17,6 +17,11 @@ internal fun PersistentIrGenerator.generateClass() { ) val superTypesField = Field("superTypes", +"List<" + import("IrType", "org.jetbrains.kotlin.ir.types") + ">", superTypeListProto) val modalityField = Field("modality", descriptorType("Modality"), modalityProto) + val inlineClassRepresentationField = Field( + "inlineClassRepresentation", + descriptorType("InlineClassRepresentation") + "<" + import("IrSimpleType", "org.jetbrains.kotlin.ir.types") + ">?", + inlineClassRepresentationProto + ) writeFile("PersistentIrClass.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -72,6 +77,7 @@ internal fun PersistentIrGenerator.generateClass() { superTypesField.toPersistentField(+"emptyList()"), +"override var metadata: " + MetadataSource + "? = null", modalityField.toPersistentField(+"modality"), + inlineClassRepresentationField.toPersistentField(+"null"), +"override var attributeOwnerId: " + IrAttributeContainer + " = this", ), id, @@ -86,6 +92,7 @@ internal fun PersistentIrGenerator.generateClass() { modalityField, typeParametersField, superTypesField, + inlineClassRepresentationField, )() }) @@ -96,5 +103,6 @@ internal fun PersistentIrGenerator.generateClass() { modalityField, typeParametersField, superTypesField, + inlineClassRepresentationField, ) -} \ No newline at end of file +} diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/PersistentIrGenerator.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/PersistentIrGenerator.kt index dd2d105c223..e2c04e4b2a0 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/PersistentIrGenerator.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/PersistentIrGenerator.kt @@ -3,11 +3,11 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ +@file:Suppress("MemberVisibilityCanBePrivate") + package org.jetbrains.kotlin.ir.persistentIrGenerator import java.io.File -import java.lang.IllegalStateException -import java.lang.StringBuilder internal interface R { fun text(t: String): R @@ -156,6 +156,11 @@ internal object PersistentIrGenerator { val visibilityProto = Proto(null, "visibility", +"Long", DescriptorVisibility) val modalityProto = Proto(null, "modality", +"Long", descriptorType("Modality")) + val inlineClassRepresentationProto = Proto( + "IrInlineClassRepresentation", "inlineClassRepresentation", + import("IrInlineClassRepresentation", protoPackage, "ProtoIrInlineClassRepresentation"), + descriptorType("InlineClassRepresentation") + "<" + import("IrSimpleType", "org.jetbrains.kotlin.ir.types") + ">" + ) val isExternalClassProto = Proto(null, "isExternalClass", +"Long", +"Boolean") val isExternalFieldProto = Proto(null, "isExternalField", +"Long", +"Boolean") @@ -180,6 +185,7 @@ internal object PersistentIrGenerator { variableProto, visibilityProto, modalityProto, + inlineClassRepresentationProto, isExternalClassProto, isExternalFieldProto, isExternalFunctionProto, diff --git a/compiler/ir/ir.tree.persistent/src/org/jetbrains/kotlin/ir/serialization/IrCarrierDeserializerImpl.kt b/compiler/ir/ir.tree.persistent/src/org/jetbrains/kotlin/ir/serialization/IrCarrierDeserializerImpl.kt index 24a8d6c93e9..d118522c215 100644 --- a/compiler/ir/ir.tree.persistent/src/org/jetbrains/kotlin/ir/serialization/IrCarrierDeserializerImpl.kt +++ b/compiler/ir/ir.tree.persistent/src/org/jetbrains/kotlin/ir/serialization/IrCarrierDeserializerImpl.kt @@ -8,8 +8,8 @@ package org.jetbrains.kotlin.ir.serialization import org.jetbrains.kotlin.backend.common.serialization.IrDeclarationDeserializer import org.jetbrains.kotlin.backend.common.serialization.IrFlags import org.jetbrains.kotlin.descriptors.DescriptorVisibility +import org.jetbrains.kotlin.descriptors.InlineClassRepresentation import org.jetbrains.kotlin.descriptors.Modality -import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrVariable import org.jetbrains.kotlin.ir.expressions.IrBlockBody @@ -17,11 +17,12 @@ import org.jetbrains.kotlin.ir.expressions.IrBody import org.jetbrains.kotlin.ir.expressions.IrConstructorCall import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.symbols.* +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility - import org.jetbrains.kotlin.backend.common.serialization.proto.IrConstructorCall as ProtoIrConstructorCall +import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation as ProtoIrInlineClassRepresentation import org.jetbrains.kotlin.backend.common.serialization.proto.IrVariable as ProtoIrVariable internal class IrCarrierDeserializerImpl( @@ -102,6 +103,10 @@ internal class IrCarrierDeserializerImpl( return ProtoEnumFlags.modality(IrFlags.MODALITY.get(proto.toInt())) } + override fun deserializeInlineClassRepresentation(proto: ProtoIrInlineClassRepresentation): InlineClassRepresentation { + return declarationDeserializer.deserializeInlineClassRepresentation(proto) + } + override fun deserializeIsExternalClass(proto: Long): Boolean { return IrFlags.IS_EXTERNAL_CLASS.get(proto.toInt()) } @@ -117,4 +122,4 @@ internal class IrCarrierDeserializerImpl( override fun deserializeIsExternalProperty(proto: Long): Boolean { return IrFlags.IS_EXTERNAL_PROPERTY.get(proto.toInt()) } -} \ No newline at end of file +} diff --git a/compiler/ir/ir.tree.persistent/src/org/jetbrains/kotlin/ir/serialization/IrCarrierSerializerImpl.kt b/compiler/ir/ir.tree.persistent/src/org/jetbrains/kotlin/ir/serialization/IrCarrierSerializerImpl.kt index 350b7b6c740..df4df65bc44 100644 --- a/compiler/ir/ir.tree.persistent/src/org/jetbrains/kotlin/ir/serialization/IrCarrierSerializerImpl.kt +++ b/compiler/ir/ir.tree.persistent/src/org/jetbrains/kotlin/ir/serialization/IrCarrierSerializerImpl.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.ir.serialization import org.jetbrains.kotlin.backend.common.serialization.IrFileSerializer import org.jetbrains.kotlin.backend.common.serialization.IrFlags import org.jetbrains.kotlin.descriptors.DescriptorVisibility +import org.jetbrains.kotlin.descriptors.InlineClassRepresentation import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrVariable @@ -16,12 +17,13 @@ import org.jetbrains.kotlin.ir.expressions.IrBody import org.jetbrains.kotlin.ir.expressions.IrConstructorCall import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.symbols.* +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.metadata.deserialization.Flags import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility - import org.jetbrains.kotlin.backend.common.serialization.proto.IrConstructorCall as ProtoIrConstructorCall +import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation as ProtoIrInlineClassRepresentation import org.jetbrains.kotlin.backend.common.serialization.proto.IrVariable as ProtoIrVariable internal class IrCarrierSerializerImpl(val fileSerializer: IrFileSerializer, val bodyIndex: (IrBody) -> Int) : IrCarrierSerializer() { @@ -97,6 +99,10 @@ internal class IrCarrierSerializerImpl(val fileSerializer: IrFileSerializer, val return Flags.MODALITY.toFlags(ProtoEnumFlags.modality(value)).toLong() } + override fun serializeInlineClassRepresentation(value: InlineClassRepresentation): ProtoIrInlineClassRepresentation { + return fileSerializer.serializeInlineClassRepresentation(value) + } + override fun serializeIsExternalClass(value: Boolean): Long { return IrFlags.IS_EXTERNAL_CLASS.toFlags(value).toLong() } @@ -112,4 +118,4 @@ internal class IrCarrierSerializerImpl(val fileSerializer: IrFileSerializer, val override fun serializeIsExternalProperty(value: Boolean): Long { return IrFlags.IS_EXTERNAL_PROPERTY.toFlags(value).toLong() } -} \ No newline at end of file +} diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt index 3de4027ca0a..bf36b4eff3b 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt @@ -16,12 +16,10 @@ package org.jetbrains.kotlin.ir.declarations -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.descriptors.Modality -import org.jetbrains.kotlin.descriptors.SourceElement +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.symbols.IrClassSymbol +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.util.transformInPlace import org.jetbrains.kotlin.ir.util.transformIfNeeded @@ -51,6 +49,8 @@ abstract class IrClass : abstract var thisReceiver: IrValueParameter? + abstract var inlineClassRepresentation: InlineClassRepresentation? + override fun accept(visitor: IrElementVisitor, data: D): R = visitor.visitClass(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyClass.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyClass.kt index 61c21eec304..c17e6632e8d 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyClass.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyClass.kt @@ -10,9 +10,11 @@ import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.IrConstructorCall import org.jetbrains.kotlin.ir.symbols.IrClassSymbol +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator import org.jetbrains.kotlin.ir.util.TypeTranslator +import org.jetbrains.kotlin.ir.util.render import org.jetbrains.kotlin.metadata.ProtoBuf import org.jetbrains.kotlin.metadata.deserialization.NameResolver import org.jetbrains.kotlin.name.Name @@ -99,6 +101,12 @@ class IrLazyClass( } } + override var inlineClassRepresentation: InlineClassRepresentation? by lazyVar(stubGenerator.lock) { + descriptor.inlineClassRepresentation?.mapUnderlyingType { + it.toIrType() as? IrSimpleType ?: error("Inline class underlying type is not a simple type: ${render()}") + } + } + override var attributeOwnerId: IrAttributeContainer = this val classProto: ProtoBuf.Class? get() = (descriptor as? DeserializedClassDescriptor)?.classProto diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt index 9f2a63c5c36..4c497d71c66 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.* import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.symbols.impl.IrAnonymousInitializerSymbolImpl +import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.acceptVoid @@ -156,6 +157,7 @@ open class DeepCopyIrTreeWithSymbols( it.remapType() } thisReceiver = declaration.thisReceiver?.transform() + inlineClassRepresentation = declaration.inlineClassRepresentation?.mapUnderlyingType { it.remapType() as IrSimpleType } declaration.transformDeclarationsTo(this) }.copyAttributes(declaration) diff --git a/compiler/ir/serialization.common/src/KotlinIr.proto b/compiler/ir/serialization.common/src/KotlinIr.proto index cd0d27c3db2..943ccf883f9 100644 --- a/compiler/ir/serialization.common/src/KotlinIr.proto +++ b/compiler/ir/serialization.common/src/KotlinIr.proto @@ -507,6 +507,7 @@ message IrClass { repeated IrTypeParameter type_parameter = 4; repeated IrDeclaration declaration = 5; repeated int32 super_type = 6 [packed=true]; + optional IrInlineClassRepresentation inline_class_representation = 7; } message IrTypeAlias { @@ -590,7 +591,12 @@ message IrStatement { } } +message IrInlineClassRepresentation { + required int32 underlying_property_name = 1; + required int32 underlying_property_type = 2; +} + message PirBodyCarrier { required int32 lastModified = 1; optional int64 containerFieldSymbol = 2; -} \ No newline at end of file +} diff --git a/compiler/ir/serialization.common/src/KotlinPirCarriers.proto b/compiler/ir/serialization.common/src/KotlinPirCarriers.proto index 2130d22b7f7..91931577dde 100644 --- a/compiler/ir/serialization.common/src/KotlinPirCarriers.proto +++ b/compiler/ir/serialization.common/src/KotlinPirCarriers.proto @@ -25,7 +25,8 @@ message PirClassCarrier { optional int64 thisReceiver = 5; repeated int64 typeParameters = 6; repeated int32 superTypes = 7; - optional int64 flags = 8 [default = 0]; + optional IrInlineClassRepresentation inlineClassRepresentation = 8; + optional int64 flags = 9 [default = 0]; } message PirConstructorCarrier { diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrDeclarationDeserializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrDeclarationDeserializer.kt index edb24a5ad41..ddfcc78f426 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrDeclarationDeserializer.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrDeclarationDeserializer.kt @@ -11,18 +11,24 @@ import org.jetbrains.kotlin.backend.common.overrides.FakeOverrideClassFilter import org.jetbrains.kotlin.backend.common.serialization.encodings.* import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclaration.DeclaratorCase.* import org.jetbrains.kotlin.backend.common.serialization.proto.IrType.KindCase.* +import org.jetbrains.kotlin.descriptors.InlineClassRepresentation import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl -import org.jetbrains.kotlin.ir.descriptors.* -import org.jetbrains.kotlin.ir.expressions.* +import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns +import org.jetbrains.kotlin.ir.expressions.IrBlockBody +import org.jetbrains.kotlin.ir.expressions.IrBody +import org.jetbrains.kotlin.ir.expressions.IrConstructorCall +import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.expressions.impl.IrErrorExpressionImpl import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.symbols.impl.IrPublicSymbolBase import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.types.impl.* -import org.jetbrains.kotlin.ir.util.* +import org.jetbrains.kotlin.ir.util.IdSignature +import org.jetbrains.kotlin.ir.util.SymbolTable +import org.jetbrains.kotlin.ir.util.withScope import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.protobuf.CodedInputStream import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite @@ -35,16 +41,17 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclaration as import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase as ProtoDeclarationBase import org.jetbrains.kotlin.backend.common.serialization.proto.IrDynamicType as ProtoDynamicType import org.jetbrains.kotlin.backend.common.serialization.proto.IrEnumEntry as ProtoEnumEntry +import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration as ProtoErrorDeclaration import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorType as ProtoErrorType +import org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression as ProtoExpression import org.jetbrains.kotlin.backend.common.serialization.proto.IrField as ProtoField import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunction as ProtoFunction import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionBase as ProtoFunctionBase -import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration as ProtoErrorDeclaration -import org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression as ProtoExpression -import org.jetbrains.kotlin.backend.common.serialization.proto.IrStatement as ProtoStatement +import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation as ProtoIrInlineClassRepresentation import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedProperty as ProtoLocalDelegatedProperty import org.jetbrains.kotlin.backend.common.serialization.proto.IrProperty as ProtoProperty import org.jetbrains.kotlin.backend.common.serialization.proto.IrSimpleType as ProtoSimpleType +import org.jetbrains.kotlin.backend.common.serialization.proto.IrStatement as ProtoStatement import org.jetbrains.kotlin.backend.common.serialization.proto.IrType as ProtoType import org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeAbbreviation as ProtoTypeAbbreviation import org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeAlias as ProtoTypeAlias @@ -319,11 +326,21 @@ class IrDeclarationDeserializer( thisReceiver = deserializeIrValueParameter(proto.thisReceiver, -1) + inlineClassRepresentation = + if (proto.hasInlineClassRepresentation()) deserializeInlineClassRepresentation(proto.inlineClassRepresentation) + else null + fakeOverrideBuilder.enqueueClass(this, signature) } } } + fun deserializeInlineClassRepresentation(proto: ProtoIrInlineClassRepresentation): InlineClassRepresentation = + InlineClassRepresentation( + deserializeName(proto.underlyingPropertyName), + deserializeIrType(proto.underlyingPropertyType) as IrSimpleType, + ) + private fun deserializeIrTypeAlias(proto: ProtoTypeAlias): IrTypeAlias = withDeserializedIrDeclarationBase(proto.base) { symbol, uniqId, startOffset, endOffset, origin, fcode -> require(symbol is IrTypeAliasSymbol) @@ -721,4 +738,4 @@ class IrDeclarationDeserializer( else -> false } } -} \ No newline at end of file +} diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt index 36aeeb9ee31..ee0da162722 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt @@ -8,8 +8,8 @@ package org.jetbrains.kotlin.backend.common.serialization import org.jetbrains.kotlin.backend.common.ir.ir2string import org.jetbrains.kotlin.backend.common.serialization.encodings.* import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.ir.IrFileEntry import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.IrFileEntry import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.symbols.* @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.library.impl.IrMemoryDeclarationWriter import org.jetbrains.kotlin.library.impl.IrMemoryStringWriter import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance +import org.jetbrains.kotlin.backend.common.serialization.proto.AccessorIdSignature as ProtoAccessorIdSignature import org.jetbrains.kotlin.backend.common.serialization.proto.Actual as ProtoActual import org.jetbrains.kotlin.backend.common.serialization.proto.FieldAccessCommon as ProtoFieldAccessCommon import org.jetbrains.kotlin.backend.common.serialization.proto.FileEntry as ProtoFileEntry @@ -52,9 +53,9 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrDynamicOperator import org.jetbrains.kotlin.backend.common.serialization.proto.IrDynamicType as ProtoDynamicType import org.jetbrains.kotlin.backend.common.serialization.proto.IrEnumConstructorCall as ProtoEnumConstructorCall import org.jetbrains.kotlin.backend.common.serialization.proto.IrEnumEntry as ProtoEnumEntry +import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression as ProtoErrorCallExpression import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration as ProtoErrorDeclaration import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression as ProtoErrorExpression -import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression as ProtoErrorCallExpression import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorType as ProtoErrorType import org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression as ProtoExpression import org.jetbrains.kotlin.backend.common.serialization.proto.IrField as ProtoField @@ -68,6 +69,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrGetEnumValue as import org.jetbrains.kotlin.backend.common.serialization.proto.IrGetField as ProtoGetField import org.jetbrains.kotlin.backend.common.serialization.proto.IrGetObject as ProtoGetObject import org.jetbrains.kotlin.backend.common.serialization.proto.IrGetValue as ProtoGetValue +import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation as ProtoIrInlineClassRepresentation import org.jetbrains.kotlin.backend.common.serialization.proto.IrInstanceInitializerCall as ProtoInstanceInitializerCall import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedProperty as ProtoLocalDelegatedProperty import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedPropertyReference as ProtoLocalDelegatedPropertyReference @@ -101,7 +103,6 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.Loop as ProtoLoop import org.jetbrains.kotlin.backend.common.serialization.proto.MemberAccessCommon as ProtoMemberAccessCommon import org.jetbrains.kotlin.backend.common.serialization.proto.NullableIrExpression as ProtoNullableIrExpression import org.jetbrains.kotlin.backend.common.serialization.proto.PublicIdSignature as ProtoPublicIdSignature -import org.jetbrains.kotlin.backend.common.serialization.proto.AccessorIdSignature as ProtoAccessorIdSignature open class IrFileSerializer( val messageLogger: IrMessageLogger, @@ -1149,6 +1150,11 @@ open class IrFileSerializer( .setBase(serializeIrDeclarationBase(clazz, ClassFlags.encode(clazz))) .setName(serializeName(clazz.name)) + val representation = clazz.inlineClassRepresentation + if (representation != null) { + proto.inlineClassRepresentation = serializeInlineClassRepresentation(representation) + } + if (!skipMutableState) { clazz.declarations.forEach { if (memberNeedsSerialization(it)) proto.addDeclaration(serializeDeclaration(it)) @@ -1168,6 +1174,13 @@ open class IrFileSerializer( return proto.build() } + fun serializeInlineClassRepresentation(representation: InlineClassRepresentation): ProtoIrInlineClassRepresentation = + ProtoIrInlineClassRepresentation.newBuilder().apply { + underlyingPropertyName = serializeName(representation.underlyingPropertyName) + // TODO: consider not writing type if the property is public, similarly to metadata + underlyingPropertyType = serializeIrType(representation.underlyingType) + }.build() + private fun serializeIrTypeAlias(typeAlias: IrTypeAlias): ProtoTypeAlias { val proto = ProtoTypeAlias.newBuilder() @@ -1400,4 +1413,3 @@ open class IrFileSerializer( } } } - diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClass.java b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClass.java index e6245862e9a..0d1b53545a4 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClass.java +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClass.java @@ -121,6 +121,19 @@ public final class IrClass extends input.popLimit(limit); break; } + case 58: { + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = inlineClassRepresentation_.toBuilder(); + } + inlineClassRepresentation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(inlineClassRepresentation_); + inlineClassRepresentation_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -302,6 +315,21 @@ public final class IrClass extends } private int superTypeMemoizedSerializedSize = -1; + public static final int INLINE_CLASS_REPRESENTATION_FIELD_NUMBER = 7; + private org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + public boolean hasInlineClassRepresentation() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation getInlineClassRepresentation() { + return inlineClassRepresentation_; + } + private void initFields() { base_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.getDefaultInstance(); name_ = 0; @@ -309,6 +337,7 @@ public final class IrClass extends typeParameter_ = java.util.Collections.emptyList(); declaration_ = java.util.Collections.emptyList(); superType_ = java.util.Collections.emptyList(); + inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -346,6 +375,12 @@ public final class IrClass extends return false; } } + if (hasInlineClassRepresentation()) { + if (!getInlineClassRepresentation().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } memoizedIsInitialized = 1; return true; } @@ -375,6 +410,9 @@ public final class IrClass extends for (int i = 0; i < superType_.size(); i++) { output.writeInt32NoTag(superType_.get(i)); } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(7, inlineClassRepresentation_); + } output.writeRawBytes(unknownFields); } @@ -418,6 +456,10 @@ public final class IrClass extends } superTypeMemoizedSerializedSize = dataSize; } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(7, inlineClassRepresentation_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -524,6 +566,8 @@ public final class IrClass extends bitField0_ = (bitField0_ & ~0x00000010); superType_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000020); + inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000040); return this; } @@ -574,6 +618,10 @@ public final class IrClass extends bitField0_ = (bitField0_ & ~0x00000020); } result.superType_ = superType_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000008; + } + result.inlineClassRepresentation_ = inlineClassRepresentation_; result.bitField0_ = to_bitField0_; return result; } @@ -619,6 +667,9 @@ public final class IrClass extends } } + if (other.hasInlineClassRepresentation()) { + mergeInlineClassRepresentation(other.getInlineClassRepresentation()); + } setUnknownFields( getUnknownFields().concat(other.unknownFields)); return this; @@ -655,6 +706,12 @@ public final class IrClass extends return false; } } + if (hasInlineClassRepresentation()) { + if (!getInlineClassRepresentation().isInitialized()) { + + return false; + } + } return true; } @@ -1145,6 +1202,66 @@ public final class IrClass extends return this; } + private org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + public boolean hasInlineClassRepresentation() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation getInlineClassRepresentation() { + return inlineClassRepresentation_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + public Builder setInlineClassRepresentation(org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation value) { + if (value == null) { + throw new NullPointerException(); + } + inlineClassRepresentation_ = value; + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + public Builder setInlineClassRepresentation( + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.Builder builderForValue) { + inlineClassRepresentation_ = builderForValue.build(); + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + public Builder mergeInlineClassRepresentation(org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation value) { + if (((bitField0_ & 0x00000040) == 0x00000040) && + inlineClassRepresentation_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance()) { + inlineClassRepresentation_ = + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.newBuilder(inlineClassRepresentation_).mergeFrom(value).buildPartial(); + } else { + inlineClassRepresentation_ = value; + } + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + public Builder clearInlineClassRepresentation() { + inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrClass) } diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClassOrBuilder.java b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClassOrBuilder.java index 7032f738e11..72773ae0142 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClassOrBuilder.java +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClassOrBuilder.java @@ -74,4 +74,13 @@ public interface IrClassOrBuilder extends * repeated int32 super_type = 6 [packed = true]; */ int getSuperType(int index); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + boolean hasInlineClassRepresentation(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inline_class_representation = 7; + */ + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation getInlineClassRepresentation(); } \ No newline at end of file diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrInlineClassRepresentation.java b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrInlineClassRepresentation.java new file mode 100644 index 00000000000..5c2c743b1a1 --- /dev/null +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrInlineClassRepresentation.java @@ -0,0 +1,428 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: compiler/ir/serialization.common/src/KotlinIr.proto + +package org.jetbrains.kotlin.backend.common.serialization.proto; + +/** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation} + */ +public final class IrInlineClassRepresentation extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation) + IrInlineClassRepresentationOrBuilder { + // Use IrInlineClassRepresentation.newBuilder() to construct. + private IrInlineClassRepresentation(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrInlineClassRepresentation(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrInlineClassRepresentation defaultInstance; + public static IrInlineClassRepresentation getDefaultInstance() { + return defaultInstance; + } + + public IrInlineClassRepresentation getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrInlineClassRepresentation( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput = + org.jetbrains.kotlin.protobuf.ByteString.newOutput(); + org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput = + org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance( + unknownFieldsOutput, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + underlyingPropertyName_ = input.readInt32(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + underlyingPropertyType_ = input.readInt32(); + break; + } + } + } + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + try { + unknownFieldsCodedOutput.flush(); + } catch (java.io.IOException e) { + // Should not happen + } finally { + unknownFields = unknownFieldsOutput.toByteString(); + } + makeExtensionsImmutable(); + } + } + public static org.jetbrains.kotlin.protobuf.Parser PARSER = + new org.jetbrains.kotlin.protobuf.AbstractParser() { + public IrInlineClassRepresentation parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrInlineClassRepresentation(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int UNDERLYING_PROPERTY_NAME_FIELD_NUMBER = 1; + private int underlyingPropertyName_; + /** + * required int32 underlying_property_name = 1; + */ + public boolean hasUnderlyingPropertyName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 underlying_property_name = 1; + */ + public int getUnderlyingPropertyName() { + return underlyingPropertyName_; + } + + public static final int UNDERLYING_PROPERTY_TYPE_FIELD_NUMBER = 2; + private int underlyingPropertyType_; + /** + * required int32 underlying_property_type = 2; + */ + public boolean hasUnderlyingPropertyType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 underlying_property_type = 2; + */ + public int getUnderlyingPropertyType() { + return underlyingPropertyType_; + } + + private void initFields() { + underlyingPropertyName_ = 0; + underlyingPropertyType_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasUnderlyingPropertyName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasUnderlyingPropertyType()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt32(1, underlyingPropertyName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, underlyingPropertyType_); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32Size(1, underlyingPropertyName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32Size(2, underlyingPropertyType_); + } + size += unknownFields.size(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseFrom( + byte[] data, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseFrom( + java.io.InputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseDelimitedFrom( + java.io.InputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation) + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentationOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + underlyingPropertyName_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + underlyingPropertyType_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation build() { + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.underlyingPropertyName_ = underlyingPropertyName_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.underlyingPropertyType_ = underlyingPropertyType_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance()) return this; + if (other.hasUnderlyingPropertyName()) { + setUnderlyingPropertyName(other.getUnderlyingPropertyName()); + } + if (other.hasUnderlyingPropertyType()) { + setUnderlyingPropertyType(other.getUnderlyingPropertyType()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasUnderlyingPropertyName()) { + + return false; + } + if (!hasUnderlyingPropertyType()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int underlyingPropertyName_ ; + /** + * required int32 underlying_property_name = 1; + */ + public boolean hasUnderlyingPropertyName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 underlying_property_name = 1; + */ + public int getUnderlyingPropertyName() { + return underlyingPropertyName_; + } + /** + * required int32 underlying_property_name = 1; + */ + public Builder setUnderlyingPropertyName(int value) { + bitField0_ |= 0x00000001; + underlyingPropertyName_ = value; + + return this; + } + /** + * required int32 underlying_property_name = 1; + */ + public Builder clearUnderlyingPropertyName() { + bitField0_ = (bitField0_ & ~0x00000001); + underlyingPropertyName_ = 0; + + return this; + } + + private int underlyingPropertyType_ ; + /** + * required int32 underlying_property_type = 2; + */ + public boolean hasUnderlyingPropertyType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 underlying_property_type = 2; + */ + public int getUnderlyingPropertyType() { + return underlyingPropertyType_; + } + /** + * required int32 underlying_property_type = 2; + */ + public Builder setUnderlyingPropertyType(int value) { + bitField0_ |= 0x00000002; + underlyingPropertyType_ = value; + + return this; + } + /** + * required int32 underlying_property_type = 2; + */ + public Builder clearUnderlyingPropertyType() { + bitField0_ = (bitField0_ & ~0x00000002); + underlyingPropertyType_ = 0; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation) + } + + static { + defaultInstance = new IrInlineClassRepresentation(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation) +} \ No newline at end of file diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrInlineClassRepresentationOrBuilder.java b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrInlineClassRepresentationOrBuilder.java new file mode 100644 index 00000000000..664746d254a --- /dev/null +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrInlineClassRepresentationOrBuilder.java @@ -0,0 +1,27 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: compiler/ir/serialization.common/src/KotlinIr.proto + +package org.jetbrains.kotlin.backend.common.serialization.proto; + +public interface IrInlineClassRepresentationOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 underlying_property_name = 1; + */ + boolean hasUnderlyingPropertyName(); + /** + * required int32 underlying_property_name = 1; + */ + int getUnderlyingPropertyName(); + + /** + * required int32 underlying_property_type = 2; + */ + boolean hasUnderlyingPropertyType(); + /** + * required int32 underlying_property_type = 2; + */ + int getUnderlyingPropertyType(); +} \ No newline at end of file diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirClassCarrier.java b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirClassCarrier.java index 61ff901c1d0..7139206d517 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirClassCarrier.java +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirClassCarrier.java @@ -123,8 +123,21 @@ public final class PirClassCarrier extends input.popLimit(limit); break; } - case 64: { + case 66: { + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = inlineClassRepresentation_.toBuilder(); + } + inlineClassRepresentation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(inlineClassRepresentation_); + inlineClassRepresentation_ = subBuilder.buildPartial(); + } bitField0_ |= 0x00000010; + break; + } + case 72: { + bitField0_ |= 0x00000020; flags_ = input.readInt64(); break; } @@ -310,16 +323,31 @@ public final class PirClassCarrier extends return superTypes_.get(index); } - public static final int FLAGS_FIELD_NUMBER = 8; - private long flags_; + public static final int INLINECLASSREPRESENTATION_FIELD_NUMBER = 8; + private org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation_; /** - * optional int64 flags = 8 [default = 0]; + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; */ - public boolean hasFlags() { + public boolean hasInlineClassRepresentation() { return ((bitField0_ & 0x00000010) == 0x00000010); } /** - * optional int64 flags = 8 [default = 0]; + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation getInlineClassRepresentation() { + return inlineClassRepresentation_; + } + + public static final int FLAGS_FIELD_NUMBER = 9; + private long flags_; + /** + * optional int64 flags = 9 [default = 0]; + */ + public boolean hasFlags() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional int64 flags = 9 [default = 0]; */ public long getFlags() { return flags_; @@ -333,6 +361,7 @@ public final class PirClassCarrier extends thisReceiver_ = 0L; typeParameters_ = java.util.Collections.emptyList(); superTypes_ = java.util.Collections.emptyList(); + inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance(); flags_ = 0L; } private byte memoizedIsInitialized = -1; @@ -351,6 +380,12 @@ public final class PirClassCarrier extends return false; } } + if (hasInlineClassRepresentation()) { + if (!getInlineClassRepresentation().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } memoizedIsInitialized = 1; return true; } @@ -380,7 +415,10 @@ public final class PirClassCarrier extends output.writeInt32(7, superTypes_.get(i)); } if (((bitField0_ & 0x00000010) == 0x00000010)) { - output.writeInt64(8, flags_); + output.writeMessage(8, inlineClassRepresentation_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeInt64(9, flags_); } output.writeRawBytes(unknownFields); } @@ -431,7 +469,11 @@ public final class PirClassCarrier extends } if (((bitField0_ & 0x00000010) == 0x00000010)) { size += org.jetbrains.kotlin.protobuf.CodedOutputStream - .computeInt64Size(8, flags_); + .computeMessageSize(8, inlineClassRepresentation_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt64Size(9, flags_); } size += unknownFields.size(); memoizedSerializedSize = size; @@ -541,8 +583,10 @@ public final class PirClassCarrier extends bitField0_ = (bitField0_ & ~0x00000020); superTypes_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000040); - flags_ = 0L; + inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance(); bitField0_ = (bitField0_ & ~0x00000080); + flags_ = 0L; + bitField0_ = (bitField0_ & ~0x00000100); return this; } @@ -600,6 +644,10 @@ public final class PirClassCarrier extends if (((from_bitField0_ & 0x00000080) == 0x00000080)) { to_bitField0_ |= 0x00000010; } + result.inlineClassRepresentation_ = inlineClassRepresentation_; + if (((from_bitField0_ & 0x00000100) == 0x00000100)) { + to_bitField0_ |= 0x00000020; + } result.flags_ = flags_; result.bitField0_ = to_bitField0_; return result; @@ -649,6 +697,9 @@ public final class PirClassCarrier extends } } + if (other.hasInlineClassRepresentation()) { + mergeInlineClassRepresentation(other.getInlineClassRepresentation()); + } if (other.hasFlags()) { setFlags(other.getFlags()); } @@ -668,6 +719,12 @@ public final class PirClassCarrier extends return false; } } + if (hasInlineClassRepresentation()) { + if (!getInlineClassRepresentation().isInitialized()) { + + return false; + } + } return true; } @@ -1075,33 +1132,93 @@ public final class PirClassCarrier extends return this; } - private long flags_ ; + private org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance(); /** - * optional int64 flags = 8 [default = 0]; + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; */ - public boolean hasFlags() { + public boolean hasInlineClassRepresentation() { return ((bitField0_ & 0x00000080) == 0x00000080); } /** - * optional int64 flags = 8 [default = 0]; + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation getInlineClassRepresentation() { + return inlineClassRepresentation_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; + */ + public Builder setInlineClassRepresentation(org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation value) { + if (value == null) { + throw new NullPointerException(); + } + inlineClassRepresentation_ = value; + + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; + */ + public Builder setInlineClassRepresentation( + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.Builder builderForValue) { + inlineClassRepresentation_ = builderForValue.build(); + + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; + */ + public Builder mergeInlineClassRepresentation(org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation value) { + if (((bitField0_ & 0x00000080) == 0x00000080) && + inlineClassRepresentation_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance()) { + inlineClassRepresentation_ = + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.newBuilder(inlineClassRepresentation_).mergeFrom(value).buildPartial(); + } else { + inlineClassRepresentation_ = value; + } + + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; + */ + public Builder clearInlineClassRepresentation() { + inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + private long flags_ ; + /** + * optional int64 flags = 9 [default = 0]; + */ + public boolean hasFlags() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * optional int64 flags = 9 [default = 0]; */ public long getFlags() { return flags_; } /** - * optional int64 flags = 8 [default = 0]; + * optional int64 flags = 9 [default = 0]; */ public Builder setFlags(long value) { - bitField0_ |= 0x00000080; + bitField0_ |= 0x00000100; flags_ = value; return this; } /** - * optional int64 flags = 8 [default = 0]; + * optional int64 flags = 9 [default = 0]; */ public Builder clearFlags() { - bitField0_ = (bitField0_ & ~0x00000080); + bitField0_ = (bitField0_ & ~0x00000100); flags_ = 0L; return this; diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirClassCarrierOrBuilder.java b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirClassCarrierOrBuilder.java index 294271fb644..b6c1f133467 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirClassCarrierOrBuilder.java +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirClassCarrierOrBuilder.java @@ -84,11 +84,20 @@ public interface PirClassCarrierOrBuilder extends int getSuperTypes(int index); /** - * optional int64 flags = 8 [default = 0]; + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; + */ + boolean hasInlineClassRepresentation(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation inlineClassRepresentation = 8; + */ + org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation getInlineClassRepresentation(); + + /** + * optional int64 flags = 9 [default = 0]; */ boolean hasFlags(); /** - * optional int64 flags = 8 [default = 0]; + * optional int64 flags = 9 [default = 0]; */ long getFlags(); } \ No newline at end of file diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirInlineClassRepresentationOrBuilder.java b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirInlineClassRepresentationOrBuilder.java new file mode 100644 index 00000000000..86685d59f20 --- /dev/null +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/PirInlineClassRepresentationOrBuilder.java @@ -0,0 +1,27 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: compiler/ir/serialization.common/src/KotlinIr.proto + +package org.jetbrains.kotlin.backend.common.serialization.proto; + +public interface PirInlineClassRepresentationOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.PirInlineClassRepresentation) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 underlying_property_name = 1; + */ + boolean hasUnderlyingPropertyName(); + /** + * required int32 underlying_property_name = 1; + */ + int getUnderlyingPropertyName(); + + /** + * required int32 underlying_property_type = 2; + */ + boolean hasUnderlyingPropertyType(); + /** + * required int32 underlying_property_type = 2; + */ + int getUnderlyingPropertyType(); +} \ No newline at end of file diff --git a/core/compiler.common/src/org/jetbrains/kotlin/descriptors/InlineClassRepresentation.kt b/core/compiler.common/src/org/jetbrains/kotlin/descriptors/InlineClassRepresentation.kt index ad6b207135a..cebea35e545 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/descriptors/InlineClassRepresentation.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/descriptors/InlineClassRepresentation.kt @@ -11,4 +11,7 @@ import org.jetbrains.kotlin.types.model.SimpleTypeMarker class InlineClassRepresentation( val underlyingPropertyName: Name, val underlyingType: Type, -) +) { + inline fun mapUnderlyingType(transform: (Type) -> Other): InlineClassRepresentation = + InlineClassRepresentation(underlyingPropertyName, transform(underlyingType)) +}