From 1f0d83b4205933df702c8ed909439af352746c7c Mon Sep 17 00:00:00 2001 From: Anton Bannykh Date: Fri, 2 Apr 2021 17:44:35 +0300 Subject: [PATCH] JS PIR: update the generator - Use symbols in carriers - .proto messages for carriers - carrier serializer/derserializer --- .../AnonymousInitializer.kt | 4 +- .../kotlin/ir/persistentIrGenerator/Class.kt | 33 +- .../ir/persistentIrGenerator/Constructor.kt | 35 +- .../ir/persistentIrGenerator/EnumEntry.kt | 15 +- .../persistentIrGenerator/ErrorDeclaration.kt | 2 + .../kotlin/ir/persistentIrGenerator/Field.kt | 12 +- .../ir/persistentIrGenerator/Function.kt | 38 +- .../LocalDelegatedProperty.kt | 35 +- .../kotlin/ir/persistentIrGenerator/Main.kt | 4 + .../PersistentIrGenerator.kt | 437 +++++++++++++++++- .../ir/persistentIrGenerator/Property.kt | 42 +- .../ir/persistentIrGenerator/TypeAlias.kt | 5 +- .../ir/persistentIrGenerator/TypeParameter.kt | 4 +- .../persistentIrGenerator/ValueParameter.kt | 8 +- 14 files changed, 580 insertions(+), 94 deletions(-) diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/AnonymousInitializer.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/AnonymousInitializer.kt index 62caa036963..f07880bb45c 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/AnonymousInitializer.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/AnonymousInitializer.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateAnonymousInitializer() { - val body = Field("body", IrBlockBody, lateinit = true) + val body = Field("body", IrBlockBody, blockBodyProto, lateinit = true) writeFile("PersistentIrAnonymousInitializer.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -33,4 +33,6 @@ internal fun PersistentIrGenerator.generateAnonymousInitializer() { writeFile("carriers/AnonymousInitializerCarrier.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent.carriers") { carriers("AnonymousInitializer", body)() }) + + addCarrierProtoMessage("AnonymousInitializer", body) } \ No newline at end of file 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 6426eba2e97..fb3a24c311c 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 @@ -6,13 +6,17 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateClass() { - val visibilityField = Field("visibility", descriptorType("DescriptorVisibility")) - val thisReceiverField = Field("thisReceiver", irDeclaration("IrValueParameter") + "?") - val typeParametersField = Field("typeParameters", +"List<" + irDeclaration("IrTypeParameter") + ">") - val superTypesField = Field("superTypes", +"List<" + import("IrType", "org.jetbrains.kotlin.ir.types") + ">") - val metadataField = Field("metadata", irDeclaration("MetadataSource") + "?") - val modalityField = Field("modality", descriptorType("Modality")) - val attributeOwnerIdField = Field("attributeOwnerId", IrAttributeContainer) + val visibilityField = Field("visibility", DescriptorVisibility, visibilityProto) + val thisReceiverField = Field( + "thisReceiver", + IrValueParameter + "?", + valueParameterProto, + propSymbolType = IrValueParameterSymbol + "?", + symbolToDeclaration = +"?.owner", + declarationToSymbol = +"?.symbol" + ) + val superTypesField = Field("superTypes", +"List<" + import("IrType", "org.jetbrains.kotlin.ir.types") + ">", superTypeListProto) + val modalityField = Field("modality", descriptorType("Modality"), modalityProto) writeFile("PersistentIrClass.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -66,9 +70,9 @@ internal fun PersistentIrGenerator.generateClass() { ), typeParametersField.toPersistentField(+"emptyList()"), superTypesField.toPersistentField(+"emptyList()"), - metadataField.toPersistentField(+"null"), + +"override var metadata: " + MetadataSource + "? = null", modalityField.toPersistentField(+"modality"), - attributeOwnerIdField.toPersistentField(+"this"), + +"override var attributeOwnerId: " + IrAttributeContainer + " = this", ), id, )() @@ -78,12 +82,19 @@ internal fun PersistentIrGenerator.generateClass() { carriers( "Class", thisReceiverField, - metadataField, visibilityField, modalityField, - attributeOwnerIdField, typeParametersField, superTypesField, )() }) + + addCarrierProtoMessage( + "Class", + thisReceiverField, + visibilityField, + modalityField, + typeParametersField, + superTypesField, + ) } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Constructor.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Constructor.kt index d9eed09dc3f..b3e4fb41a49 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Constructor.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Constructor.kt @@ -6,14 +6,9 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateConstructor() { - val returnTypeFieldField = Field("returnTypeField", IrType) - val typeParametersField = Field("typeParameters", +"List<" + IrTypeParameter + ">") - val dispatchReceiverParameterField = Field("dispatchReceiverParameter", IrValueParameter + "?") - val extensionReceiverParameterField = Field("extensionReceiverParameter", IrValueParameter + "?") - val valueParametersField = Field("valueParameters", +"List<" + IrValueParameter + ">") - val bodyField = Field("body", IrBody + "?") - val metadataField = Field("metadata", MetadataSource + "?") - val visibilityField = Field("visibility", DescriptorVisibility) + val returnTypeFieldField = Field("returnTypeField", IrType, typeProto) + val bodyField = Field("body", IrBody + "?", bodyProto) + val visibilityField = Field("visibility", DescriptorVisibility, visibilityProto) writeFile("PersistentIrConstructor.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -42,7 +37,13 @@ internal fun PersistentIrGenerator.generateConstructor() { +"override var returnType: IrType", lines( +"get() = returnTypeField.let " + block( - +"if (it !== " + import("IrUninitializedType", "org.jetbrains.kotlin.ir.types.impl") + ") it else throw " + import("ReturnTypeIsNotInitializedException", "org.jetbrains.kotlin.ir.types.impl") + "(this)" + +"if (it !== " + import( + "IrUninitializedType", + "org.jetbrains.kotlin.ir.types.impl" + ) + ") it else throw " + import( + "ReturnTypeIsNotInitializedException", + "org.jetbrains.kotlin.ir.types.impl" + ) + "(this)" ), +"set(c) " + block( +"returnTypeField = c" @@ -54,9 +55,9 @@ internal fun PersistentIrGenerator.generateConstructor() { extensionReceiverParameterField.toPersistentField(+"null"), valueParametersField.toPersistentField(+"emptyList()"), bodyField.toBody(), - metadataField.toPersistentField(+"null"), + +"override var metadata: " + MetadataSource + "? = null", visibilityField.toPersistentField(+"visibility"), - descriptor(ClassConstructorDescriptor) + descriptor(ClassConstructorDescriptor), ), id, )() @@ -69,10 +70,20 @@ internal fun PersistentIrGenerator.generateConstructor() { dispatchReceiverParameterField, extensionReceiverParameterField, bodyField, - metadataField, visibilityField, typeParametersField, valueParametersField, )() }) + + addCarrierProtoMessage( + "Constructor", + returnTypeFieldField, + dispatchReceiverParameterField, + extensionReceiverParameterField, + bodyField, + visibilityField, + typeParametersField, + valueParametersField, + ) } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/EnumEntry.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/EnumEntry.kt index 8481431a91f..551f7443094 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/EnumEntry.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/EnumEntry.kt @@ -6,8 +6,15 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateEnumEntry() { - val correspondingClassField = Field("correspondingClass", IrClass + "?") - val initializerExpressionField = Field("initializerExpression", IrExpressionBody + "?") + val correspondingClassField = Field( + "correspondingClass", + IrClass + "?", + classProto, + propSymbolType = IrClassSymbol + "?", + symbolToDeclaration = +"?.owner", + declarationToSymbol = +"?.symbol" + ) + val initializerExpressionField = Field("initializerExpression", IrExpressionBody + "?", expressionBodyProto) writeFile("PersistentIrEnumEntry.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -27,7 +34,7 @@ internal fun PersistentIrGenerator.generateEnumEntry() { descriptor(ClassDescriptor), correspondingClassField.toPersistentField(+"null"), - initializerExpressionField.toBody() + initializerExpressionField.toBody(), ), id, )() @@ -40,4 +47,6 @@ internal fun PersistentIrGenerator.generateEnumEntry() { initializerExpressionField, )() }) + + addCarrierProtoMessage("EnumEntry", correspondingClassField, initializerExpressionField) } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/ErrorDeclaration.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/ErrorDeclaration.kt index 3a39539dbc2..5fb3407e6dd 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/ErrorDeclaration.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/ErrorDeclaration.kt @@ -43,4 +43,6 @@ internal fun PersistentIrGenerator.generateErrorDeclaration() { "ErrorDeclaration", )() }) + + addCarrierProtoMessage("ErrorDeclaration") } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Field.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Field.kt index b7ee1b9bd28..be997f93c02 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Field.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Field.kt @@ -6,10 +6,9 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateField() { - val initializerField = Field("initializer", IrExpressionBody + "?") - val correspondingPropertySymbolField = Field("correspondingPropertySymbol", IrPropertySymbol + "?") - val metadataField = Field("metadata", MetadataSource + "?") - val typeField = Field("type", IrType) + val initializerField = Field("initializer", IrExpressionBody + "?", expressionBodyProto) + val correspondingPropertySymbolField = Field("correspondingPropertySymbol", IrPropertySymbol + "?", propertySymbolProto) + val typeField = Field("type", IrType, typeProto) writeFile("PersistentIrField.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -34,7 +33,7 @@ internal fun PersistentIrGenerator.generateField() { descriptor(descriptorType("PropertyDescriptor")), initializerField.toBody(), correspondingPropertySymbolField.toPersistentField(+"null"), - metadataField.toPersistentField(+"null"), + +"override var metadata: " + MetadataSource + "? = null", typeField.toPersistentField(+"type"), ), id, @@ -47,7 +46,8 @@ internal fun PersistentIrGenerator.generateField() { typeField, initializerField, correspondingPropertySymbolField, - metadataField, )() }) + + addCarrierProtoMessage("Field", typeField, initializerField, correspondingPropertySymbolField) } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Function.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Function.kt index 19177cbf584..915c2decd0a 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Function.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Function.kt @@ -7,17 +7,11 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateFunction() { - val returnTypeFieldField = Field("returnTypeField", IrType) - val typeParametersField = Field("typeParameters", +"List<" + IrTypeParameter + ">") - val dispatchReceiverParameterField = Field("dispatchReceiverParameter", IrValueParameter + "?") - val extensionReceiverParameterField = Field("extensionReceiverParameter", IrValueParameter + "?") - val valueParametersField = Field("valueParameters", +"List<" + IrValueParameter + ">") - val bodyField = Field("body", IrBody + "?") - val metadataField = Field("metadata", MetadataSource + "?") - val visibilityField = Field("visibility", DescriptorVisibility) - val overriddenSymbolsField = Field("overriddenSymbols", +"List<" + irSymbol("IrSimpleFunctionSymbol") + ">") - val attributeOwnerIdField = Field("attributeOwnerId", IrAttributeContainer) - val correspondingPropertySymbolField = Field("correspondingPropertySymbol", IrPropertySymbol + "?") + val returnTypeFieldField = Field("returnTypeField", IrType, typeProto) + val bodyField = Field("body", IrBody + "?", bodyProto) + val visibilityField = Field("visibility", DescriptorVisibility, visibilityProto) + val overriddenSymbolsField = Field("overriddenSymbols", +"List<" + IrSimpleFunctionSymbol + ">", simpleFunctionSymbolListProto) + val correspondingPropertySymbolField = Field("correspondingPropertySymbol", IrPropertySymbol + "?", propertySymbolProto) writeFile("PersistentIrFunctionCommon.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -65,13 +59,10 @@ internal fun PersistentIrGenerator.generateFunction() { extensionReceiverParameterField.toPersistentField(+"null"), valueParametersField.toPersistentField(+"emptyList()"), bodyField.toBody(), - metadataField.toPersistentField(+"null"), + +"override var metadata: " + MetadataSource + "? = null", visibilityField.toPersistentField(+"visibility"), overriddenSymbolsField.toPersistentField(+"emptyList()"), - lines( - +"@Suppress(\"LeakingThis\")", - attributeOwnerIdField.toPersistentField(+"this"), - ), + +"override var attributeOwnerId: " + IrAttributeContainer + " = this", correspondingPropertySymbolField.toPersistentField(+"null"), ), id, @@ -85,13 +76,24 @@ internal fun PersistentIrGenerator.generateFunction() { dispatchReceiverParameterField, extensionReceiverParameterField, bodyField, - metadataField, visibilityField, typeParametersField, valueParametersField, correspondingPropertySymbolField, overriddenSymbolsField, - attributeOwnerIdField, )() }) + + addCarrierProtoMessage( + "Function", + returnTypeFieldField, + dispatchReceiverParameterField, + extensionReceiverParameterField, + bodyField, + visibilityField, + typeParametersField, + valueParametersField, + correspondingPropertySymbolField, + overriddenSymbolsField, + ) } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/LocalDelegatedProperty.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/LocalDelegatedProperty.kt index 6ff921d3ea0..16bef07d87d 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/LocalDelegatedProperty.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/LocalDelegatedProperty.kt @@ -6,11 +6,25 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateLocalDelegatedProperty() { - val typeField = Field("type", IrType) - val delegateField = Field("delegate", irDeclaration("IrVariable"), lateinit = true) - val getterField = Field("getter", irDeclaration("IrSimpleFunction"), lateinit = true) - val setterField = Field("setter", irDeclaration("IrSimpleFunction") + "?") - val metadataField = Field("metadata", MetadataSource + "?") + val typeField = Field("type", IrType, typeProto) + val delegateField = Field("delegate", IrVariable, variableProto, lateinit = true) + val getterField = Field( + "getter", + IrSimpleFunction, + simpleFunctionProto, + lateinit = true, + propSymbolType = IrSimpleFunctionSymbol, + symbolToDeclaration = +".owner", + declarationToSymbol = +".symbol" + ) + val setterField = Field( + "setter", + IrSimpleFunction + "?", + simpleFunctionProto, + propSymbolType = IrSimpleFunctionSymbol + "?", + symbolToDeclaration = +"?.owner", + declarationToSymbol = +"?.symbol" + ) writeFile("PersistentIrLocalDelegatedProperty.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -35,7 +49,7 @@ internal fun PersistentIrGenerator.generateLocalDelegatedProperty() { delegateField.toPersistentField(+"null"), getterField.toPersistentField(+"null"), setterField.toPersistentField(+"null"), - metadataField.toPersistentField(+"null"), + +"override var metadata: " + MetadataSource + "? = null", ), id, )() @@ -48,7 +62,14 @@ internal fun PersistentIrGenerator.generateLocalDelegatedProperty() { delegateField, getterField, setterField, - metadataField, )() }) + + addCarrierProtoMessage( + "LocalDelegatedProperty", + typeField, + delegateField, + getterField, + setterField, + ) } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Main.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Main.kt index 5932c5b8e82..f1734fc5249 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Main.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Main.kt @@ -19,5 +19,9 @@ fun main() { generateTypeAlias() generateTypeParameter() generateValueParameter() + + updateKotlinIrProto() + generateCarrierDeserializer() + generateCarrierSerializer() } } \ 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 187919a6989..ab5525c9222 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 @@ -6,8 +6,8 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator import java.io.File +import java.lang.IllegalStateException import java.lang.StringBuilder -import java.time.Year internal interface R { fun text(t: String): R @@ -19,12 +19,42 @@ internal interface R { internal typealias E = R.() -> R -internal class Field(val name: String, val type: E, val lateinit: Boolean = false, val notEq: String = "!==") +internal val id: E get() = { this } + +internal enum class FieldKind { + REQUIRED, OPTIONAL, REPEATED +} + +internal class Proto( + val protoPrefix: String?, // null if flag, proto type if not + val entityName: String, // what to deserialize + val protoType: E, // what type ProtoBuf generates + val irType: E, // what Ir class this maps to + val fieldKind: FieldKind = FieldKind.OPTIONAL, +) + +internal class Field( + val name: String, + val propType: E, + val proto: Proto? = null, + val lateinit: Boolean = false, + val notEq: String = "!==", + val propSymbolType: E? = null, + val symbolToDeclaration: E = id, + val declarationToSymbol: E = id, + val storeInCarrierImpl: Boolean = false, +) internal object PersistentIrGenerator { + private val protoPackage = "org.jetbrains.kotlin.backend.common.serialization.proto" + val carrierPackage = "org.jetbrains.kotlin.ir.declarations.persistent.carriers" + // Imports + val codedInputStream: E = import("codedInputStream", "org.jetbrains.kotlin.backend.common.serialization") + val ExtensionRegistryLite: E = import("ExtensionRegistryLite", "org.jetbrains.kotlin.protobuf") + val ClassDescriptor: E = descriptorType("ClassDescriptor") val DeclarationDescriptor: E = descriptorType("DeclarationDescriptor") val ClassConstructorDescriptor: E = descriptorType("ClassConstructorDescriptor") @@ -35,10 +65,14 @@ internal object PersistentIrGenerator { val IrDeclarationParent = irDeclaration("IrDeclarationParent") val IrAnonymousInitializer = irDeclaration("IrAnonymousInitializer") val IrClass = irDeclaration("IrClass") + val IrFunction = irDeclaration("IrFunction") + val IrSimpleFunction = irDeclaration("IrSimpleFunction") + val IrField = irDeclaration("IrField") val IrTypeParameter = irDeclaration("IrTypeParameter") val IrValueParameter = irDeclaration("IrValueParameter") val MetadataSource = irDeclaration("MetadataSource") val IrAttributeContainer = irDeclaration("IrAttributeContainer") + val IrVariable = irDeclaration("IrVariable") val IrConstructorCall = irExpression("IrConstructorCall") val IrBody = irExpression("IrBody") @@ -55,7 +89,13 @@ internal object PersistentIrGenerator { val IrType = import("IrType", "org.jetbrains.kotlin.ir.types") + val IrSymbol = irSymbol("IrSymbol") val IrPropertySymbol = irSymbol("IrPropertySymbol") + val IrSimpleFunctionSymbol = irSymbol("IrSimpleFunctionSymbol") + val IrFunctionSymbol = irSymbol("IrFunctionSymbol") + val IrFieldSymbol = irSymbol("IrFieldSymbol") + val IrValueParameterSymbol = irSymbol("IrValueParameterSymbol") + val IrTypeParameterSymbol = irSymbol("IrTypeParameterSymbol") // Constructor parameters @@ -78,7 +118,10 @@ internal object PersistentIrGenerator { val source = +"override val source: " + descriptorType("SourceElement") + " = SourceElement.NO_SOURCE" val returnType = +"returnType: " + IrType val isPrimary = +"override val isPrimary: Boolean" - val containerSource = +"override val containerSource: " + import("DeserializedContainerSource", "org.jetbrains.kotlin.serialization.deserialization.descriptors") + "?" + val containerSource = +"override val containerSource: " + import( + "DeserializedContainerSource", + "org.jetbrains.kotlin.serialization.deserialization.descriptors" + ) + "?" val irFactory = +"override val factory: PersistentIrFactory" @@ -86,6 +129,63 @@ internal object PersistentIrGenerator { +"symbol.bind(this)" ) + // Proto types + + val protoValueParameterType = import("IrValueParameter", protoPackage, "ProtoIrValueParameter") + val protoTypeParameterType = import("IrTypeParameter", protoPackage, "ProtoIrTypeParameter") + val protoVariable = import("IrVariable", protoPackage, "ProtoIrVariable") + val protoIrConstructorCall = import("IrConstructorCall", protoPackage, "ProtoIrConstructorCall") + + val bodyProto = Proto("int32", "body", +"Int", IrBody) + val blockBodyProto = Proto("int32", "blockBody", +"Int", IrBlockBody) + val expressionBodyProto = Proto("int32", "expressionBody", +"Int", IrExpressionBody) + val valueParameterProto = Proto("int64", "valueParameter", +"Long", IrValueParameterSymbol) + val valueParameterListProto = Proto("int64", "valueParameter", +"Long", IrValueParameterSymbol, fieldKind = FieldKind.REPEATED) + val typeParameterListProto = Proto("int64", "typeParameter", +"Long", IrTypeParameterSymbol, fieldKind = FieldKind.REPEATED) + val superTypeListProto = Proto("int32", "superType", +"Int", IrType, fieldKind = FieldKind.REPEATED) + val typeProto = Proto("int32", "type", +"Int", IrType, fieldKind = FieldKind.REQUIRED) + val optionalTypeProto = Proto("int32", "type", +"Int", IrType, fieldKind = FieldKind.OPTIONAL) + val variableProto = Proto("IrVariable", "variable", protoVariable, IrVariable) + + val classProto = Proto("int64", "class", +"Long", IrClassSymbol) + val propertySymbolProto = Proto("int64", "propertySymbol", +"Long", IrPropertySymbol) + val simpleFunctionProto = Proto("int64", "simpleFunction", +"Long", IrSimpleFunctionSymbol) + val simpleFunctionSymbolListProto = + Proto("int64", "simpleFunctionSymbol", +"Long", IrSimpleFunctionSymbol, fieldKind = FieldKind.REPEATED) + val fieldProto = Proto("int64", "field", +"Long", IrFieldSymbol) + + val visibilityProto = Proto(null, "visibility", +"Long", DescriptorVisibility) + val modalityProto = Proto(null, "modality", +"Long", descriptorType("Modality")) + + val isExternalClassProto = Proto(null, "isExternalClass", +"Long", +"Boolean") + val isExternalFieldProto = Proto(null, "isExternalField", +"Long", +"Boolean") + val isExternalFunctionProto = Proto(null, "isExternalFunction", +"Long", +"Boolean") + val isExternalPropertyProto = Proto(null, "isExternalProperty", +"Long", +"Boolean") + + private val allProto = listOf( + bodyProto, + blockBodyProto, + expressionBodyProto, + valueParameterProto, + valueParameterListProto, + typeParameterListProto, + superTypeListProto, + typeProto, + optionalTypeProto, + classProto, + propertySymbolProto, + simpleFunctionProto, + simpleFunctionSymbolListProto, + fieldProto, + variableProto, + visibilityProto, + modalityProto, + isExternalClassProto, + isExternalFieldProto, + isExternalFunctionProto, + isExternalPropertyProto, + ) + // Fields val lastModified = +"override var lastModified: Int = factory.stageController.currentStage" val loweredUpTo = +"override var loweredUpTo: Int = factory.stageController.currentStage" @@ -109,10 +209,214 @@ internal object PersistentIrGenerator { annotationsField, ) - fun Field.toPersistentField(initializer: E, modifier: String = "override") = - persistentField(name, type, initializer, lateinit, modifier, notEq = notEq) + val typeParametersField = Field( + "typeParameters", + +"List<" + IrTypeParameter + ">", + typeParameterListProto, + propSymbolType = +"List<" + IrTypeParameterSymbol + ">", + symbolToDeclaration = +".map { it.owner }", + declarationToSymbol = +".map { it.symbol }", + storeInCarrierImpl = true, + ) - fun Field.toBody() = body(type, lateinit, name) + val valueParametersField = Field( + "valueParameters", + +"List<" + IrValueParameter + ">", + valueParameterListProto, + propSymbolType = +"List<" + IrValueParameterSymbol + ">", + symbolToDeclaration = +".map { it.owner }", + declarationToSymbol = +".map { it.symbol }", + storeInCarrierImpl = true, + ) + + val dispatchReceiverParameterField = Field( + "dispatchReceiverParameter", + IrValueParameter + "?", + valueParameterProto, + propSymbolType = IrValueParameterSymbol + "?", + symbolToDeclaration = +"?.owner", + declarationToSymbol = +"?.symbol" + ) + + val extensionReceiverParameterField = Field( + "extensionReceiverParameter", + IrValueParameter + "?", + valueParameterProto, + propSymbolType = IrValueParameterSymbol + "?", + symbolToDeclaration = +"?.owner", + declarationToSymbol = +"?.symbol" + ) + + fun Field.toPersistentField(initializer: E, modifier: String = "override") = + persistentField( + name, + propType, + initializer, + lateinit, + modifier, + notEq = notEq, + symbolType = propSymbolType, + declarationToSymbol = declarationToSymbol, + symbolToDeclaration = symbolToDeclaration, + ) + + fun Field.toBody() = body(propType, lateinit, name) + + val protoMessages = mutableListOf() + + fun addCarrierProtoMessage(carrierName: String, vararg fields: Field) { + val protoFields = mutableListOf( + "required int32 lastModified", + "optional int64 parentSymbol", + "optional int32 origin", + "repeated IrConstructorCall annotation" + ) + + protoFields += fields.mapNotNull { f -> + f.proto?.protoPrefix?.let { p -> + val modifier = f.proto.fieldKind.toString().toLowerCase() + "$modifier $p ${f.name}" + } + } + + val sb = StringBuilder("message Pir${carrierName}Carrier {\n") + protoFields.forEachIndexed { i, f -> + sb.append(" $f = ${i + 1}") + sb.append(";\n") + } + + if (fields.any { it.proto != null && it.proto.protoPrefix == null }) { + sb.append(" optional int64 flags = ${protoFields.size + 1} [default = 0];\n") + } + + sb.append("}\n") + + protoMessages += sb.toString() + + addDeserializerMessage(carrierName, *fields) + addSerializerMessage(carrierName, *fields) + } + + val deserializerMethods = mutableListOf().also { list -> + + list += +"abstract fun deserializeParentSymbol(proto: Long): " + IrSymbol + list += +"abstract fun deserializeOrigin(proto: Int): " + IrDeclarationOrigin + list += +"abstract fun deserializeAnnotation(proto: " + protoIrConstructorCall + "): " + IrConstructorCall + + val seenEntities = mutableSetOf() + + allProto.forEach { p -> + if (p.entityName !in seenEntities) { + seenEntities += p.entityName + list += +"abstract fun deserialize${p.entityName.capitalize()}(proto: " + p.protoType + "): " + p.irType + } + } + } + + fun addDeserializerMessage(carrierName: String, vararg fields: Field) { + val argumentType = import("Pir${carrierName}Carrier", protoPackage) + val returnType = import("${carrierName}Carrier", carrierPackage) + val carrierImpl = import("${carrierName}CarrierImpl", carrierPackage) + + deserializerMethods += lines( + +"fun deserialize${carrierName}Carrier(bytes: ByteArray): " + returnType + " {", + lines( + +"val proto = " + argumentType + ".parseFrom(bytes." + codedInputStream + ", " + ExtensionRegistryLite + ".newInstance())", + +"return " + carrierImpl + "(", + arrayOf( + +"proto.lastModified", + +"if (proto.hasParentSymbol()) deserializeParentSymbol(proto.parentSymbol) else null", + +"deserializeOrigin(proto.origin)", + +"proto.annotationList.map { deserializeAnnotation(it) }", + *fields.map { f -> + if (f.proto == null) { + +"null" + } else { + val deserialize = "deserialize${f.proto.entityName.capitalize()}" + + when { + f.proto.fieldKind == FieldKind.REPEATED -> + +"proto.${f.name}List.map { $deserialize(it) }" + f.proto.protoPrefix != null && f.proto.fieldKind == FieldKind.OPTIONAL -> + +"if (proto.has${f.name.capitalize()}()) $deserialize(proto.${f.name}) else null" + f.proto.protoPrefix == null -> + +"$deserialize(proto.flags)" + else -> + +"$deserialize(proto.${f.name})" + } + } + }.toTypedArray() + ).join(separator = ",\n").indent(), + +")", + ).indent(), + +"}", + ) + } + + val serializerMethods = mutableListOf().also { list -> + + list += +"abstract fun serializeParentSymbol(value: " + IrSymbol + "): Long" + list += +"abstract fun serializeOrigin(value: " + IrDeclarationOrigin + "): Int" + list += +"abstract fun serializeAnnotation(value: " + IrConstructorCall + "): " + protoIrConstructorCall + + val seenEntities = mutableSetOf() + + allProto.forEach { p -> + if (p.entityName !in seenEntities) { + seenEntities += p.entityName + list += +"abstract fun serialize${p.entityName.capitalize()}(value: " + p.irType + "): " + p.protoType + } + } + } + + + fun addSerializerMessage(carrierName: String, vararg fields: Field) { + val argumentType = import("${carrierName}Carrier", carrierPackage) + val returnType = import("Pir${carrierName}Carrier", protoPackage) + + var flagsHandled = false + + serializerMethods += lines( + +"fun serialize${carrierName}Carrier(carrier: " + argumentType + "): ByteArray {", + lines( + +"val proto = " + returnType + ".newBuilder()", + +"proto.setLastModified(carrier.lastModified)", + +"carrier.parentSymbolField?.let { proto.setParentSymbol(serializeParentSymbol(it)) }", + +"proto.setOrigin(serializeOrigin(carrier.originField))", + +"proto.addAllAnnotation(carrier.annotationsField.map { serializeAnnotation(it) })", + *(fields.mapNotNull { f -> + f.proto?.let { p -> + if (p.protoPrefix != null) { + val action = "proto." + (if (p.fieldKind == FieldKind.REPEATED) "addAll" else "set") + f.name.capitalize() + val serializationFun = "serialize${f.proto.entityName.capitalize()}" + val argument = "carrier.${f.name}${if (f.propSymbolType != null) "Symbol" else ""}Field" + + when { + p.fieldKind == FieldKind.OPTIONAL -> + +"$argument?.let { $action($serializationFun(it)) }" + p.fieldKind == FieldKind.REPEATED -> + +"$action($argument.map { $serializationFun(it) })" + else -> + +"$action($serializationFun($argument))" + } + } else { + // It's a flag + if (!flagsHandled) { + flagsHandled = true + val flags = fields.filter { it.proto?.protoPrefix == null } + + val calls = flags.map { f -> "serialize${f.proto!!.entityName.capitalize()}(carrier.${f.name}Field)" } + + +"proto.setFlags(${calls.joinToString(separator = " or ")})" + } else null + } + } + }).toTypedArray(), + +"return proto.build().toByteArray()", + ).indent(), + +"}", + ) + } // Helpers @@ -130,11 +434,24 @@ internal object PersistentIrGenerator { modifier: String = "override", isBody: Boolean = false, notEq: String = "!==", - ): E = lines( - +"override var ${name}Field: " + type + "${if (lateinit) "?" else ""} = " + initializer, - id, - +"$modifier var $name: " + type, - lines( + symbolType: E? = null, + declarationToSymbol: E = id, + symbolToDeclaration: E = id, + ): E { + val result = mutableListOf(+"override var ${name}Field: " + type + "${if (lateinit) "?" else ""} = " + initializer, id) + if (symbolType != null) { + result += +"override var ${name}SymbolField: " + symbolType + if (lateinit) "?" else "" + result += lines( + +"get() = ${name}Field" + (if (lateinit) "?" else "") + declarationToSymbol, + +"set(v) " + block( + +"${name}Field = v" + (if (lateinit) "?" else "") + symbolToDeclaration + ) + ).indent() + result += id + } + + result += +"$modifier var $name: " + type + result += lines( +"get() = getCarrier().${name}Field${if (lateinit) "!!" else ""}", +"set(v) " + block( +"if (${if (lateinit) "getCarrier().${name}Field" else name} $notEq v) " + block( @@ -148,7 +465,9 @@ internal object PersistentIrGenerator { ) ) ).indent() - ) + + return lines(*result.toTypedArray()) + } fun body(bodyType: E, lateinit: Boolean = false, fieldName: String = "body"): E = persistentField(fieldName, bodyType, initializer = +"null", lateinit, isBody = true) @@ -162,16 +481,24 @@ internal object PersistentIrGenerator { fun carriers(name: String, vararg fields: Field): E = lines( id, +"internal interface ${name}Carrier : DeclarationCarrier" + block( - *(fields.map { +"val ${it.name}Field: " + it.type + if (it.lateinit) "?" else "" }.toTypedArray()), + *(fields.flatMap { + var result = listOf(+"val ${it.name}Field: " + it.propType + if (it.lateinit) "?" else "") + + if (it.propSymbolType != null) { + result += +"val ${it.name}SymbolField: " + it.propSymbolType + if (it.lateinit) "?" else "" + } + + result + }.toTypedArray()), id, +"override fun clone(): ${name}Carrier " + block( +"return ${name}CarrierImpl(", arrayOf( +"lastModified", - +"parentField", + +"parentSymbolField", +"originField", +"annotationsField", - *(fields.map { +"${it.name}Field" }.toTypedArray()) + *(fields.map { +"${it.name}${if (it.propSymbolType != null) "Symbol" else ""}Field" }.toTypedArray()) ).join(separator = ",\n").indent(), +")", ) @@ -180,12 +507,33 @@ internal object PersistentIrGenerator { +"internal class ${name}CarrierImpl(", arrayOf( +"override val lastModified: Int", - +"override val parentField: " + IrDeclarationParent + "?", + +"override val parentSymbolField: " + IrSymbol + "?", +"override val originField: " + IrDeclarationOrigin, +"override val annotationsField: List<" + IrConstructorCall + ">", - *(fields.map { +"override val ${it.name}Field: " + it.type + if (it.lateinit) "?" else "" }.toTypedArray()), + *(fields.map { + if (it.propSymbolType != null) { + +"override val ${it.name}SymbolField: " + it.propSymbolType + if (it.lateinit) "?" else "" + } else { + +"override val ${it.name}Field: " + it.propType + if (it.lateinit) "?" else "" + } + }.toTypedArray()), ).join(separator = ",\n").indent(), - +") : ${name}Carrier", + +") : ${name}Carrier" + if (fields.all { it.propSymbolType == null }) id else + " " + blockSpaced( + *(fields.mapNotNull { + it.propSymbolType?.let { _ -> + if (it.storeInCarrierImpl) { + +"override val ${it.name}Field: " + it.propType + " by lazy { ${it.name}SymbolField" + it.symbolToDeclaration + " }" + } else { + lines( + +"override val ${it.name}Field: " + it.propType + if (it.lateinit) "?" else "", + lines( + +"get() = ${it.name}SymbolField" + (if (it.lateinit) "?" else "") + it.symbolToDeclaration, + ).indent() + ) + } + } + }).toTypedArray() + ), id, ) @@ -197,7 +545,8 @@ internal object PersistentIrGenerator { return block(*(fn.flatMap { listOf(id, it) }.toTypedArray())) } - fun import(name: String, pkg: String): E = { import("$pkg.$name").text(name) } + fun import(name: String, pkg: String, alias: String = name): E = + { import("$pkg.$name${if (alias != name) " as $alias" else ""}").text(alias) } fun descriptorType(name: String): E = import(name, "org.jetbrains.kotlin.descriptors") @@ -215,8 +564,6 @@ internal object PersistentIrGenerator { operator fun String.unaryPlus(): E = { text(this@unaryPlus) } - val id: E get() = { this } - fun E?.safe(): E = this ?: id fun Array.join(prefix: String = "", separator: String = "", suffix: String = ""): E = @@ -313,4 +660,52 @@ internal object PersistentIrGenerator { fun writeFile(path: String, content: String) { File(prefix + path).writeText(content) } + + fun updateKotlinIrProto() { + val file = File("compiler/ir/serialization.common/src/KotlinIr.proto") + + if (!file.exists()) throw IllegalStateException("KotlinIr.proto file not found!") + + val lines = file.readText().lines() + + val start = lines.indexOf("// PIR GENERATOR START") + if (start < 0) throw IllegalStateException("Couldn't find the '// PIR GENERATOR START' line. Don't know where to write generated messages.") + + val end = lines.indexOf("// PIR GENERATOR END") + if (end < 0) throw IllegalStateException("Couldn't find the '// PIR GENERATOR END' line. Don't know where to write generated messages.") + + val sb = StringBuilder(lines.subList(0, start + 1).joinToString(separator = "\n")) + + for (m in protoMessages) { + sb.append("\n").append(m) + } + + sb.append("\n").append(lines.subList(end, lines.size).joinToString(separator = "\n")) + + file.writeText(sb.toString()) + } + + fun generateCarrierDeserializer() { + writeFile("../../serialization/IrCarrierDeserializer.kt", renderFile("org.jetbrains.kotlin.ir.serialization") { + lines( + id, + +"internal abstract class IrCarrierDeserializer " + blockSpaced( + *deserializerMethods.toTypedArray() + ), + id, + )() + }) + } + + fun generateCarrierSerializer() { + writeFile("../../serialization/IrCarrierSerializer.kt", renderFile("org.jetbrains.kotlin.ir.serialization") { + lines( + id, + +"internal abstract class IrCarrierSerializer " + blockSpaced( + *serializerMethods.toTypedArray() + ), + id, + )() + }) + } } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Property.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Property.kt index b624d902bd6..4293a1b6c41 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Property.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/Property.kt @@ -6,11 +6,30 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateProperty() { - val backingFieldField = Field("backingField", irDeclaration("IrField") + "?") - val getterField = Field("getter", irDeclaration("IrSimpleFunction") + "?") - val setterField = Field("setter", irDeclaration("IrSimpleFunction") + "?") - val metadataField = Field("metadata", MetadataSource + "?") - val attributeOwnerIdField = Field("attributeOwnerId", IrAttributeContainer) + val backingFieldField = Field( + "backingField", + IrField + "?", + fieldProto, + propSymbolType = IrFieldSymbol + "?", + symbolToDeclaration = +"?.owner", + declarationToSymbol = +"?.symbol" + ) + val getterField = Field( + "getter", + IrSimpleFunction + "?", + simpleFunctionProto, + propSymbolType = IrSimpleFunctionSymbol + "?", + symbolToDeclaration = +"?.owner", + declarationToSymbol = +"?.symbol" + ) + val setterField = Field( + "setter", + IrSimpleFunction + "?", + simpleFunctionProto, + propSymbolType = IrSimpleFunctionSymbol + "?", + symbolToDeclaration = +"?.owner", + declarationToSymbol = +"?.symbol" + ) writeFile("PersistentIrPropertyCommon.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -36,10 +55,10 @@ internal fun PersistentIrGenerator.generateProperty() { backingFieldField.toPersistentField(+"null"), getterField.toPersistentField(+"null"), setterField.toPersistentField(+"null"), - metadataField.toPersistentField(+"null"), + +"override var metadata: " + MetadataSource + "? = null", lines( +"@Suppress(\"LeakingThis\")", - attributeOwnerIdField.toPersistentField(+"this"), + +"override var attributeOwnerId: " + IrAttributeContainer + " = this", ), ), id, @@ -52,8 +71,13 @@ internal fun PersistentIrGenerator.generateProperty() { backingFieldField, getterField, setterField, - metadataField, - attributeOwnerIdField, )() }) + + addCarrierProtoMessage( + "Property", + backingFieldField, + getterField, + setterField, + ) } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/TypeAlias.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/TypeAlias.kt index d7c5fda0839..a0e37b7112d 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/TypeAlias.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/TypeAlias.kt @@ -6,8 +6,7 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateTypeAlias() { - val typeParametersField = Field("typeParameters", +"List<" + IrTypeParameter + ">") - val expandedTypeField = Field("expandedType", IrType) + val expandedTypeField = Field("expandedType", IrType, typeProto) writeFile("PersistentIrTypeAlias.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -43,4 +42,6 @@ internal fun PersistentIrGenerator.generateTypeAlias() { expandedTypeField, )() }) + + addCarrierProtoMessage("TypeAlias", typeParametersField, expandedTypeField) } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/TypeParameter.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/TypeParameter.kt index ff04267b62a..f1657d3cde3 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/TypeParameter.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/TypeParameter.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateTypeParameter() { - val superTypesField = Field("superTypes", +"List<" + IrType + ">") + val superTypesField = Field("superTypes", +"List<" + IrType + ">", superTypeListProto) writeFile("PersistentIrTypeParameter.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -39,4 +39,6 @@ internal fun PersistentIrGenerator.generateTypeParameter() { superTypesField, )() }) + + addCarrierProtoMessage("TypeParameter", superTypesField) } \ No newline at end of file diff --git a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/ValueParameter.kt b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/ValueParameter.kt index 395f1ee1635..b666ed113b9 100644 --- a/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/ValueParameter.kt +++ b/compiler/ir/ir.tree.persistent/generator/src/org/jetbrains/kotlin/ir/persistentIrGenerator/ValueParameter.kt @@ -7,9 +7,9 @@ package org.jetbrains.kotlin.ir.persistentIrGenerator internal fun PersistentIrGenerator.generateValueParameter() { - val defaultValueField = Field("defaultValue", IrExpressionBody + "?") - val typeField = Field("type", IrType) - val varargElementTypeField = Field("varargElementType", IrType + "?") + val defaultValueField = Field("defaultValue", IrExpressionBody + "?", expressionBodyProto) + val typeField = Field("type", IrType, typeProto) + val varargElementTypeField = Field("varargElementType", IrType + "?", optionalTypeProto) writeFile("PersistentIrValueParameter.kt", renderFile("org.jetbrains.kotlin.ir.declarations.persistent") { lines( @@ -49,4 +49,6 @@ internal fun PersistentIrGenerator.generateValueParameter() { varargElementTypeField, )() }) + + addCarrierProtoMessage("ValueParameter", defaultValueField, typeField, varargElementTypeField) } \ No newline at end of file