From cc9323939720692ebb472b43f5a5d8cb383cb54f Mon Sep 17 00:00:00 2001 From: Alexander Gorshenev Date: Wed, 13 Mar 2019 12:47:21 +0300 Subject: [PATCH] Commonized native and js IR serialization infrastructure --- build.gradle.kts | 2 +- .../src/KotlinIr.proto} | 29 +- .../common/library/CombinedIrFileAccessor.kt | 108 + .../common/serialization/AdditionalIrUtils.kt | 196 + .../common/serialization}/DeclarationTable.kt | 39 +- .../DeserializeDescriptorReference.kt | 77 +- .../serialization/IrFakeOverrideUtils.kt} | 42 +- .../serialization}/IrModuleDeserializer.kt | 347 +- .../serialization}/IrModuleSerializer.kt | 536 +- .../common/serialization/KlibWriter.kt} | 7 +- .../common/serialization/KotlinIr.java | 61319 ++++++++++++++++ .../common/serialization/KotlinIrLinker.kt} | 132 +- .../common/serialization/KotlinMangler.kt | 265 + .../serialization}/LegacyDescriptorUtils.kt | 26 +- .../SerializeDescriptorReference.kt | 14 +- .../backend/common/serialization/UniqId.kt | 48 + .../common/serialization/UniqSymbolName.kt | 10 + .../kotlin/ir/backend/js/compiler.kt | 45 +- .../js/lower/inline/FunctionInlining.kt | 2 - .../serialization/ir/AdditionalIrUtils.kt | 100 - .../lower/serialization/ir/AnotherIrUtils.kt | 74 +- .../lower/serialization/ir/BinaryInterface.kt | 227 - .../serialization/ir/IrSerializationUtil.kt | 40 - .../serialization/ir/JsDeclarationTable.kt | 26 + .../ir/JsDescriptorReferenceDeserializer.kt | 33 + .../ir/JsDescriptorUniqIdAware.kt | 23 + .../js/lower/serialization/ir/JsIrLinker.kt | 59 + .../serialization/ir/JsIrModuleSerializer.kt | 11 + .../js/lower/serialization/ir/JsMangler.kt | 14 + .../js/lower/serialization/ir/UniqId.kt | 61 - .../lower/serialization/ir/UniqSymbolName.kt | 71 - .../generators/protobuf/GenerateProtoBuf.kt | 5 +- 32 files changed, 62790 insertions(+), 1198 deletions(-) rename compiler/ir/{backend.js/src/ir.proto => backend.common/src/KotlinIr.proto} (96%) create mode 100644 compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/library/CombinedIrFileAccessor.kt create mode 100644 compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/AdditionalIrUtils.kt rename compiler/ir/{backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir => backend.common/src/org/jetbrains/kotlin/backend/common/serialization}/DeclarationTable.kt (58%) rename compiler/ir/{backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir => backend.common/src/org/jetbrains/kotlin/backend/common/serialization}/DeserializeDescriptorReference.kt (67%) rename compiler/ir/{backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DescriptorUtils.kt => backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFakeOverrideUtils.kt} (57%) rename compiler/ir/{backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir => backend.common/src/org/jetbrains/kotlin/backend/common/serialization}/IrModuleDeserializer.kt (72%) rename compiler/ir/{backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir => backend.common/src/org/jetbrains/kotlin/backend/common/serialization}/IrModuleSerializer.kt (66%) rename compiler/ir/{backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KLibraryUtils.kt => backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KlibWriter.kt} (58%) create mode 100644 compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.java rename compiler/ir/{backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBufModuleDeserializer.kt => backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIrLinker.kt} (73%) create mode 100644 compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinMangler.kt rename compiler/ir/{backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir => backend.common/src/org/jetbrains/kotlin/backend/common/serialization}/LegacyDescriptorUtils.kt (60%) rename compiler/ir/{backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir => backend.common/src/org/jetbrains/kotlin/backend/common/serialization}/SerializeDescriptorReference.kt (89%) create mode 100644 compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/UniqId.kt create mode 100644 compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/UniqSymbolName.kt delete mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AdditionalIrUtils.kt delete mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/BinaryInterface.kt delete mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrSerializationUtil.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDeclarationTable.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDescriptorReferenceDeserializer.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDescriptorUniqIdAware.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrLinker.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrModuleSerializer.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsMangler.kt delete mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqId.kt delete mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqSymbolName.kt diff --git a/build.gradle.kts b/build.gradle.kts index 43743c7a317..32e0f87c80f 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -732,4 +732,4 @@ allprojects { repositories.redirect() } } -} \ No newline at end of file +} diff --git a/compiler/ir/backend.js/src/ir.proto b/compiler/ir/backend.common/src/KotlinIr.proto similarity index 96% rename from compiler/ir/backend.js/src/ir.proto rename to compiler/ir/backend.common/src/KotlinIr.proto index af3f717783a..b30fedf3091 100644 --- a/compiler/ir/backend.js/src/ir.proto +++ b/compiler/ir/backend.common/src/KotlinIr.proto @@ -1,7 +1,7 @@ syntax = "proto2"; -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir; +package org.jetbrains.kotlin.backend.common.serialization; -option java_outer_classname = "IrKlibProtoBuf"; +option java_outer_classname = "KotlinIr"; option optimize_for = LITE_RUNTIME; message DescriptorReference { @@ -74,6 +74,11 @@ message IrDeclarationOrigin { } } +message Name { + required String name = 1; + required bool is_special = 2; +} + /* ------ Top Level---------------------------------------------- */ message IrDeclarationContainer { @@ -89,10 +94,12 @@ message IrFile { repeated UniqId declaration_id = 1; required FileEntry file_entry = 2; required String fq_name = 3; + required Annotations annotations = 4; + repeated IrSymbol explicitly_exported_to_compiler = 5; } message IrModule { - required String name = 1; + required Name name = 1; repeated IrFile file = 2; required IrSymbolTable symbol_table = 3; required IrTypeTable type_table = 4; @@ -519,7 +526,7 @@ message IrFunction { } message IrFunctionBase { - required String name = 1; + required Name name = 1; required Visibility visibility = 2; required bool is_inline = 3; required bool is_external = 4; @@ -541,7 +548,7 @@ message IrConstructor { message IrField { required IrSymbol symbol = 1; optional IrExpression initializer = 2; - required String name = 3; + required Name name = 3; required Visibility visibility = 4; required bool is_final = 5; required bool is_external = 6; @@ -551,7 +558,7 @@ message IrField { message IrProperty { optional DescriptorReference descriptor_reference = 1; // IrProperty doesn't have a symbol at all. Preserve this rudiment for now. - required String name = 2; + required Name name = 2; required Visibility visibility = 3; required ModalityKind modality = 4; required bool is_var = 5; @@ -565,7 +572,7 @@ message IrProperty { } message IrVariable { - required String name = 1; + required Name name = 1; required IrSymbol symbol = 2; required IrTypeIndex type = 3; required bool is_var = 4; @@ -592,7 +599,7 @@ enum ModalityKind { // It is ModalityKind to not clash with Modality in descript message IrValueParameter { required IrSymbol symbol = 1; - required String name = 2; + required Name name = 2; required int32 index = 3; required IrTypeIndex type = 4; optional IrTypeIndex vararg_element_type = 5; @@ -603,7 +610,7 @@ message IrValueParameter { message IrTypeParameter { required IrSymbol symbol = 1; - required String name = 2; + required Name name = 2; required int32 index = 3; required IrTypeVariance variance = 4; repeated IrTypeIndex super_type = 5; @@ -616,7 +623,7 @@ message IrTypeParameterContainer { message IrClass { required IrSymbol symbol = 1; - required String name = 2; + required Name name = 2; required ClassKind kind = 3; required Visibility visibility = 4; required ModalityKind modality = 5; @@ -636,7 +643,7 @@ message IrEnumEntry { required IrSymbol symbol = 1; optional IrExpression initializer = 2; optional IrDeclaration corresponding_class = 3; - required String name = 4; + required Name name = 4; } message IrAnonymousInit { diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/library/CombinedIrFileAccessor.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/library/CombinedIrFileAccessor.kt new file mode 100644 index 00000000000..4de5f724e9c --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/library/CombinedIrFileAccessor.kt @@ -0,0 +1,108 @@ +/** + * Copyright 2010-2019 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.backend.common.library + +import java.io.File +import java.io.RandomAccessFile +import java.nio.MappedByteBuffer +import java.nio.channels.FileChannel +import java.nio.file.Files + +data class DeclarationId(val id: Long, val isLocal: Boolean) + + +fun File.map(mode: FileChannel.MapMode = FileChannel.MapMode.READ_ONLY, + start: Long = 0, size: Long = -1): MappedByteBuffer { + val file = RandomAccessFile(path, + if (mode == FileChannel.MapMode.READ_ONLY) "r" else "rw") + val fileSize = if (mode == FileChannel.MapMode.READ_ONLY) + file.length() else size.also { assert(size != -1L) } + return file.channel.map(mode, start, fileSize) // Shall we .also { file.close() }? +} + +class CombinedIrFileReader(file: File) { + private val buffer = file.map(FileChannel.MapMode.READ_ONLY) + private val declarationToOffsetSize = mutableMapOf>() + + init { + val declarationsCount = buffer.int + for (i in 0 until declarationsCount) { + val id = buffer.long + val isLocal = buffer.int != 0 + val offset = buffer.int + val size = buffer.int + declarationToOffsetSize[DeclarationId(id, isLocal)] = offset to size + } + } + + fun declarationBytes(id: DeclarationId): ByteArray { + val offsetSize = declarationToOffsetSize[id] ?: throw Error("No declaration with $id here") + val result = ByteArray(offsetSize.second) + buffer.position(offsetSize.first) + buffer.get(result, 0, offsetSize.second) + return result + } +} + +private const val SINGLE_INDEX_RECORD_SIZE = 20 // sizeof(Long) + 3 * sizeof(Int). +private const val INDEX_HEADER_SIZE = 4 // sizeof(Int). + +class CombinedIrFileWriter(val declarationCount: Int) { + private var currentDeclaration = 0 + private var currentPosition = 0 + private val file = Files.createTempFile("ir", "").toFile().also { + it.deleteOnExit() + } + private val randomAccessFile = RandomAccessFile(file.path, "rw") + + init { + randomAccessFile.writeInt(declarationCount) + assert(randomAccessFile.filePointer.toInt() == INDEX_HEADER_SIZE) + for (i in 0 until declarationCount) { + randomAccessFile.writeLong(-1) // id + randomAccessFile.writeInt(-1) // isLocal + randomAccessFile.writeInt(-1) // offset + randomAccessFile.writeInt(-1) // size + } + currentPosition = randomAccessFile.filePointer.toInt() + assert(currentPosition == INDEX_HEADER_SIZE + SINGLE_INDEX_RECORD_SIZE * declarationCount) + } + + fun skipDeclaration() { + currentDeclaration++ + } + + fun addDeclaration(id: DeclarationId, bytes: ByteArray) { + randomAccessFile.seek((currentDeclaration * SINGLE_INDEX_RECORD_SIZE + INDEX_HEADER_SIZE).toLong()) + randomAccessFile.writeLong(id.id) + randomAccessFile.writeInt(if (id.isLocal) 1 else 0) + randomAccessFile.writeInt(currentPosition) + randomAccessFile.writeInt(bytes.size) + randomAccessFile.seek(currentPosition.toLong()) + randomAccessFile.write(bytes) + assert(randomAccessFile.filePointer < Int.MAX_VALUE.toLong()) + currentPosition = randomAccessFile.filePointer.toInt() + currentDeclaration++ + } + + fun finishWriting(): File { + assert(currentDeclaration == declarationCount) + randomAccessFile.close() + return file + } +} + diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/AdditionalIrUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/AdditionalIrUtils.kt new file mode 100644 index 00000000000..76d74d87aa7 --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/AdditionalIrUtils.kt @@ -0,0 +1,196 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.backend.common.serialization + +import org.jetbrains.kotlin.ir.SourceManager +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.expressions.IrCall +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.ir.SourceRangeInfo +import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.declarations.IrDeclaration +import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction +import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.resolve.descriptorUtil.module +import java.io.File + + +val IrConstructor.constructedClass get() = this.parent as IrClass + +val T.original get() = this + +val IrDeclarationParent.fqNameSafe: FqName + get() = when (this) { + is IrPackageFragment -> this.fqName + is IrDeclaration -> this.parent.fqNameSafe.child(this.name) + + else -> error(this) + } + +val IrClass.classId: ClassId? + get() { + val parent = this.parent + return when (parent) { + is IrClass -> parent.classId?.createNestedClassId(this.name) + is IrPackageFragment -> ClassId.topLevel(parent.fqName.child(this.name)) + else -> null + } + } + +val IrDeclaration.name: Name + get() = when (this) { + is IrSimpleFunction -> this.name + is IrClass -> this.name + is IrEnumEntry -> this.name + is IrProperty -> this.name + is IrLocalDelegatedProperty -> this.name + is IrField -> this.name + is IrVariable -> this.name + is IrConstructor -> SPECIAL_INIT_NAME + is IrValueParameter -> this.name + else -> error(this) + } + +private val SPECIAL_INIT_NAME = Name.special("") + +val IrValueParameter.isVararg get() = this.varargElementType != null + +val IrFunction.isSuspend get() = this is IrSimpleFunction && this.isSuspend + +val IrFunction.isReal get() = this.origin != IrDeclarationOrigin.FAKE_OVERRIDE + +fun IrSimpleFunction.overrides(other: IrSimpleFunction): Boolean { + if (this == other) return true + + this.overriddenSymbols.forEach { + if (it.owner.overrides(other)) { + return true + } + } + + return false +} + +private val IrCall.annotationClass + get() = (this.symbol.owner as IrConstructor).constructedClass + +fun List.hasAnnotation(fqName: FqName): Boolean = + this.any { it.annotationClass.fqNameSafe == fqName } + +fun IrAnnotationContainer.hasAnnotation(fqName: FqName) = + this.annotations.hasAnnotation(fqName) + +fun List.findAnnotation(fqName: FqName): IrCall? = this.firstOrNull { + it.annotationClass.fqNameSafe == fqName +} +val IrDeclaration.fileEntry: SourceManager.FileEntry + get() = parent.let { + when (it) { + is IrFile -> it.fileEntry + is IrPackageFragment -> TODO("Unknown file") + is IrDeclaration -> it.fileEntry + else -> TODO("Unexpected declaration parent") + } + } + +val IrClass.isInterface: Boolean + get() = (this.kind == ClassKind.INTERFACE) + + +fun IrClass.companionObject() = this.declarations.singleOrNull {it is IrClass && it.isCompanion } + +val IrDeclaration.isGetter get() = this is IrSimpleFunction && this == this.correspondingProperty?.getter + +val IrDeclaration.isSetter get() = this is IrSimpleFunction && this == this.correspondingProperty?.setter + +val IrDeclaration.isAccessor get() = this.isGetter || this.isSetter + +val IrDeclaration.isPropertyAccessor get() = + this is IrSimpleFunction && this.correspondingProperty != null + +val IrDeclaration.isPropertyField get() = + this is IrField && this.correspondingProperty != null + +val IrDeclaration.isTopLevelDeclaration get() = + parent !is IrDeclaration && !this.isPropertyAccessor && !this.isPropertyField + +fun IrDeclaration.findTopLevelDeclaration(): IrDeclaration = when { + this.isTopLevelDeclaration -> + this + this.isPropertyAccessor -> + (this as IrSimpleFunction).correspondingProperty!!.findTopLevelDeclaration() + this.isPropertyField -> + (this as IrField).correspondingProperty!!.findTopLevelDeclaration() + else -> + (this.parent as IrDeclaration).findTopLevelDeclaration() +} + +val IrDeclaration.isAnonymousObject get() = DescriptorUtils.isAnonymousObject(this.descriptor) +val IrDeclaration.isLocal get() = DescriptorUtils.isLocal(this.descriptor) + +val IrDeclaration.module get() = this.descriptor.module + +const val SYNTHETIC_OFFSET = -2 + +val File.lineStartOffsets: IntArray + get() { + // TODO: could be incorrect, if file is not in system's line terminator format. + // Maybe use (0..document.lineCount - 1) + // .map { document.getLineStartOffset(it) } + // .toIntArray() + // as in PSI. + val separatorLength = System.lineSeparator().length + val buffer = mutableListOf() + var currentOffset = 0 + this.forEachLine { line -> + buffer.add(currentOffset) + currentOffset += line.length + separatorLength + } + buffer.add(currentOffset) + return buffer.toIntArray() + } + +val SourceManager.FileEntry.lineStartOffsets + get() = File(name).let { + if (it.exists() && it.isFile) it.lineStartOffsets else IntArray(0) + } + +class NaiveSourceBasedFileEntryImpl(override val name: String, val lineStartOffsets: IntArray = IntArray(0)) : SourceManager.FileEntry { + + //-------------------------------------------------------------------------// + + override fun getLineNumber(offset: Int): Int { + assert(offset != UNDEFINED_OFFSET) + if (offset == SYNTHETIC_OFFSET) return 0 + val index = lineStartOffsets.binarySearch(offset) + return if (index >= 0) index else -index - 2 + } + + //-------------------------------------------------------------------------// + + override fun getColumnNumber(offset: Int): Int { + assert(offset != UNDEFINED_OFFSET) + if (offset == SYNTHETIC_OFFSET) return 0 + var lineNumber = getLineNumber(offset) + return offset - lineStartOffsets[lineNumber] + } + + //-------------------------------------------------------------------------// + + override val maxOffset: Int + //get() = TODO("not implemented") + get() = UNDEFINED_OFFSET + + override fun getSourceRangeInfo(beginOffset: Int, endOffset: Int): SourceRangeInfo { + //TODO("not implemented") + return SourceRangeInfo(name, beginOffset, -1, -1, endOffset, -1, -1) + + } +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeclarationTable.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/DeclarationTable.kt similarity index 58% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeclarationTable.kt rename to compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/DeclarationTable.kt index 21ad463b302..644985fbc21 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeclarationTable.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/DeclarationTable.kt @@ -3,13 +3,12 @@ * that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +package org.jetbrains.kotlin.backend.common.serialization import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrAnonymousInitializerImpl import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns -import org.jetbrains.kotlin.ir.util.SymbolTable class DescriptorTable { private val descriptors = mutableMapOf() @@ -20,29 +19,28 @@ class DescriptorTable { } // TODO: We don't manage id clashes anyhow now. -class DeclarationTable(val builtIns: IrBuiltIns, val descriptorTable: DescriptorTable, val symbolTable: SymbolTable) { +abstract class DeclarationTable(val builtIns: IrBuiltIns, val descriptorTable: DescriptorTable, mangler: KotlinMangler): KotlinMangler by mangler { private val table = mutableMapOf() val debugIndex = mutableMapOf() val descriptors = descriptorTable - private var currentIndex = 0x1_0000_0000L + abstract protected var currentIndex: Long + protected var initialized: Boolean = false - private val FUNCTION_INDEX_START: Long - - init { - val known = builtIns.knownBuiltins - known.forEach { + open fun loadKnownBuiltins() { + builtIns.knownBuiltins.forEach { table.put(it, UniqId(currentIndex++, false)) } - - FUNCTION_INDEX_START = currentIndex - currentIndex += BUILT_IN_UNIQ_ID_GAP + initialized = true } fun uniqIdByDeclaration(value: IrDeclaration) = table.getOrPut(value) { - val index = if (isBuiltInFunction(value)) { - UniqId(FUNCTION_INDEX_START + builtInFunctionId(value), false) - } else if (value.origin == IrDeclarationOrigin.FAKE_OVERRIDE || + if (!initialized) error("DeclarationTable has not been initialized") + computeUniqIdByDeclaration(value) + } + + open protected fun computeUniqIdByDeclaration(value: IrDeclaration): UniqId { + val index = if (value.origin == IrDeclarationOrigin.FAKE_OVERRIDE || !value.isExported() || value is IrVariable || value is IrTypeParameter @@ -51,18 +49,13 @@ class DeclarationTable(val builtIns: IrBuiltIns, val descriptorTable: Descriptor ) { UniqId(currentIndex++, true) } else { - UniqId(value.uniqIdIndex, false) + UniqId(value.hashedMangle, false) } - // It can grow as large as 1/3 of ir/* size. - // debugIndex.put(index) { - // "${if (index.isLocal) "" else value.uniqSymbolName()} descriptor = ${value.descriptor}" - //}.also {it == null} - - index + return index } } // This is what we pre-populate tables with val IrBuiltIns.knownBuiltins - get() = irBuiltInsExternalPackageFragment.declarations \ No newline at end of file + get() = irBuiltInsExternalPackageFragment.declarations diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeserializeDescriptorReference.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/DeserializeDescriptorReference.kt similarity index 67% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeserializeDescriptorReference.kt rename to compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/DeserializeDescriptorReference.kt index ac97d73dff5..54d4a026f3e 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeserializeDescriptorReference.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/DeserializeDescriptorReference.kt @@ -3,10 +3,12 @@ * that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +package org.jetbrains.kotlin.backend.common.serialization +import org.jetbrains.kotlin.backend.common.serialization.UniqIdKey import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.incremental.components.NoLookupLocation +import org.jetbrains.kotlin.backend.common.serialization.resolveFakeOverrideMaybeAbstract import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -16,57 +18,53 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ abstract class DescriptorReferenceDeserializer( val currentModule: ModuleDescriptor, val resolvedForwardDeclarations: MutableMap -) { +) : DescriptorUniqIdAware { protected abstract fun resolveSpecialDescriptor(fqn: FqName): DeclarationDescriptor protected abstract fun checkIfSpecialDescriptorId(id: Long): Boolean protected abstract fun getDescriptorIdOrNull(descriptor: DeclarationDescriptor): Long? - private val cache = mutableMapOf>() + protected fun getContributedDescriptors(packageFqNameString: String, name: String): Collection { + val packageFqName = packageFqNameString.let { + if (it == "") FqName.ROOT else FqName(it) + }// TODO: whould we store an empty string in the protobuf? - private fun getContributedDescriptors(packageFqNameString: String): Collection = - cache.getOrPut(packageFqNameString) { - val packageFqName = packageFqNameString.let { - if (it == "") FqName.ROOT else FqName(it) - }// TODO: whould we store an empty string in the protobuf? - - currentModule.getPackage(packageFqName).memberScope.getContributedDescriptors() + val contributedName = if (name.startsWith(", val realMembers: Map) - private val membersCache = mutableMapOf() + private fun computeUniqIdIndex(descriptor: DeclarationDescriptor) = descriptor.getUniqId() ?: getDescriptorIdOrNull(descriptor) - - private fun computeUniqIdIndex(descriptor: DeclarationDescriptor) = descriptor.getUniqId()?.index ?: getDescriptorIdOrNull(descriptor) - - private fun getMembers(packageFqNameString: String, classFqNameString: String, - members: Collection): ClassMembers = - membersCache.getOrPut(ClassName(packageFqNameString, classFqNameString)) { - val allMembersMap = mutableMapOf() - val realMembersMap = mutableMapOf() - var classConstructorDescriptor: ClassConstructorDescriptor? = null - members.forEach { member -> - if (member is ClassConstructorDescriptor) - classConstructorDescriptor = member - val realMembers = + protected fun getMembers(members: Collection): ClassMembers { + val allMembersMap = mutableMapOf() + val realMembersMap = mutableMapOf() + var classConstructorDescriptor: ClassConstructorDescriptor? = null + members.forEach { member -> + if (member is ClassConstructorDescriptor) + classConstructorDescriptor = member + val realMembers = if (member is CallableMemberDescriptor && member.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) - member.resolveFakeOverrideMaybeAbstract().map { it.original } + member.resolveFakeOverrideMaybeAbstract() else setOf(member) - computeUniqIdIndex(member)?.let { allMembersMap[it] = member } - realMembers.map { computeUniqIdIndex(it) }.filterNotNull().forEach { realMembersMap[it] = member } - } - ClassMembers(classConstructorDescriptor, allMembersMap, realMembersMap) + computeUniqIdIndex(member)?.let { allMembersMap[it] = member } + realMembers.mapNotNull { computeUniqIdIndex(it) }.forEach { realMembersMap[it] = member } } + return ClassMembers(classConstructorDescriptor, allMembersMap, realMembersMap) + } - fun deserializeDescriptorReference( + open fun deserializeDescriptorReference( packageFqNameString: String, classFqNameString: String, name: String, @@ -82,16 +80,17 @@ abstract class DescriptorReferenceDeserializer( if (it == "") FqName.ROOT else FqName(it) }// TODO: whould we store an empty string in the protobuf? - val classFqName = FqName(classFqNameString) + val classFqName = if (classFqNameString == "") FqName.ROOT else FqName(classFqNameString) val protoIndex = index - val (clazz, members) = if (classFqNameString == "") { - Pair(null, getContributedDescriptors(packageFqNameString)) + val (clazz, members) = if (classFqNameString == "" || classFqNameString == "") { + Pair(null, getContributedDescriptors(packageFqNameString, name)) } else { val clazz = currentModule.findClassAcrossModuleDependencies(ClassId(packageFqName, classFqName, false))!! Pair(clazz, clazz.unsubstitutedMemberScope.getContributedDescriptors() + clazz.getConstructors()) } + // TODO: This is still native specific. Eliminate. if (packageFqNameString.startsWith("cnames.") || packageFqNameString.startsWith("objcnames.")) { val descriptor = currentModule.findClassAcrossModuleDependencies(ClassId(packageFqName, FqName(name), false))!! @@ -100,7 +99,7 @@ abstract class DescriptorReferenceDeserializer( ) ) { if (descriptor is DeserializedClassDescriptor) { - val uniqId = UniqId(descriptor.getUniqId()!!.index, false) + val uniqId = UniqId(descriptor.getUniqId()!!, false) val newKey = UniqIdKey(null, uniqId) val oldKey = UniqIdKey(null, UniqId(protoIndex!!, false)) @@ -126,7 +125,7 @@ abstract class DescriptorReferenceDeserializer( return resolveSpecialDescriptor(packageFqName.child(Name.identifier(name))) } - val membersWithIndices = getMembers(packageFqNameString, classFqNameString, members) + val membersWithIndices = getMembers(members) return when { isDefaultConstructor -> membersWithIndices.defaultConstructor @@ -144,4 +143,4 @@ abstract class DescriptorReferenceDeserializer( } ?: error("Could not find serialized descriptor for index: ${index} ${packageFqName},${classFqName},${name}") } -} \ No newline at end of file +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DescriptorUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFakeOverrideUtils.kt similarity index 57% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DescriptorUtils.kt rename to compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFakeOverrideUtils.kt index 4fe1ee32244..5ec56b25797 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DescriptorUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFakeOverrideUtils.kt @@ -3,11 +3,11 @@ * that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +package org.jetbrains.kotlin.backend.common.serialization -import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction /** @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.ir.declarations.* * * TODO: this method is actually a part of resolve and probably duplicates another one */ -internal fun IrSimpleFunction.resolveFakeOverride(allowAbstract: Boolean = false): IrSimpleFunction { +fun IrSimpleFunction.resolveFakeOverride(allowAbstract: Boolean = false): IrSimpleFunction { if (this.isReal) { return this } @@ -53,34 +53,22 @@ internal fun IrSimpleFunction.resolveFakeOverride(allowAbstract: Boolean = false return realSupers.first { allowAbstract || it.modality != Modality.ABSTRACT } } -internal val IrClass.isInterface: Boolean - get() = (this.kind == ClassKind.INTERFACE) +/** + * Implementation of given method. + * + * TODO: this method is actually a part of resolve and probably duplicates another one + */ +internal fun IrSimpleFunction.resolveFakeOverrideMaybeAbstract() = this.resolveFakeOverride(allowAbstract = true) -internal val IrSimpleFunction.target: IrSimpleFunction +internal fun IrProperty.resolveFakeOverrideMaybeAbstract() = this.getter!!.resolveFakeOverrideMaybeAbstract().correspondingProperty!! + +internal fun IrField.resolveFakeOverrideMaybeAbstract() = this.correspondingProperty!!.getter!!.resolveFakeOverrideMaybeAbstract().correspondingProperty!!.backingField + +val IrSimpleFunction.target: IrSimpleFunction get() = (if (modality == Modality.ABSTRACT) this else resolveFakeOverride()).original -internal val IrFunction.target: IrFunction get() = when (this) { +val IrFunction.target: IrFunction get() = when (this) { is IrSimpleFunction -> this.target is IrConstructor -> this else -> error(this) } - -val IrDeclaration.isPropertyAccessor get() = - this is IrSimpleFunction && this.correspondingProperty != null - -val IrDeclaration.isPropertyField get() = - this is IrField && this.correspondingProperty != null - -val IrDeclaration.isTopLevelDeclaration get() = - parent !is IrDeclaration && !this.isPropertyAccessor && !this.isPropertyField - -fun IrDeclaration.findTopLevelDeclaration(): IrDeclaration = when { - this.isTopLevelDeclaration -> - this - this.isPropertyAccessor -> - (this as IrSimpleFunction).correspondingProperty!!.findTopLevelDeclaration() - this.isPropertyField -> - (this as IrField).correspondingProperty!!.findTopLevelDeclaration() - else -> - (this.parent as IrDeclaration).findTopLevelDeclaration() -} \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleDeserializer.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt similarity index 72% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleDeserializer.kt rename to compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt index 4ac046eeedd..b3a63443e40 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleDeserializer.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt @@ -3,7 +3,7 @@ * that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +package org.jetbrains.kotlin.backend.common.serialization import org.jetbrains.kotlin.backend.common.LoggingContext import org.jetbrains.kotlin.backend.common.descriptors.* @@ -24,11 +24,14 @@ import org.jetbrains.kotlin.ir.types.impl.* import org.jetbrains.kotlin.ir.util.IrDeserializer import org.jetbrains.kotlin.ir.util.SymbolTable import org.jetbrains.kotlin.ir.util.render -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.* -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.OperationCase.* -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst.ValueCase.* -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.DeclaratorCase.* -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType.KindCase.* +import org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.* +import org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.OperationCase.* +import org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.ValueCase.* +import org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.DeclaratorCase.* +import org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType.KindCase.* +import org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement.VarargElementCase +import org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument.KindCase.* + import org.jetbrains.kotlin.name.Name @@ -46,12 +49,18 @@ abstract class IrModuleDeserializer( val symbolTable: SymbolTable ) : IrDeserializer { - abstract fun deserializeIrSymbol(proto: IrKlibProtoBuf.IrSymbol): IrSymbol - abstract fun deserializeIrType(proto: IrKlibProtoBuf.IrTypeIndex): IrType - abstract fun deserializeDescriptorReference(proto: IrKlibProtoBuf.DescriptorReference): DeclarationDescriptor - abstract fun deserializeString(proto: IrKlibProtoBuf.String): String + abstract fun deserializeIrSymbol(proto: KotlinIr.IrSymbol): IrSymbol + abstract fun deserializeIrType(proto: KotlinIr.IrTypeIndex): IrType + abstract fun deserializeDescriptorReference(proto: KotlinIr.DescriptorReference): DeclarationDescriptor + abstract fun deserializeString(proto: KotlinIr.String): String + abstract fun deserializeLoopHeader(loopIndex: Int, loopBuilder: () -> IrLoopBase): IrLoopBase - private fun deserializeTypeArguments(proto: IrKlibProtoBuf.TypeArguments): List { + private fun deserializeName(proto: KotlinIr.Name): Name { + val name = deserializeString(proto.name) + return if (proto.isSpecial) Name.special(name) else Name.identifier(name) + } + + private fun deserializeTypeArguments(proto: KotlinIr.TypeArguments): List { logger.log { "### deserializeTypeArguments" } val result = mutableListOf() proto.typeArgumentList.forEach { typeProto -> @@ -62,34 +71,35 @@ abstract class IrModuleDeserializer( return result } - fun deserializeIrTypeVariance(variance: IrKlibProtoBuf.IrTypeVariance) = when (variance) { - IrKlibProtoBuf.IrTypeVariance.IN -> Variance.IN_VARIANCE - IrKlibProtoBuf.IrTypeVariance.OUT -> Variance.OUT_VARIANCE - IrKlibProtoBuf.IrTypeVariance.INV -> Variance.INVARIANT + fun deserializeIrTypeVariance(variance: KotlinIr.IrTypeVariance) = when (variance) { + KotlinIr.IrTypeVariance.IN -> Variance.IN_VARIANCE + KotlinIr.IrTypeVariance.OUT -> Variance.OUT_VARIANCE + KotlinIr.IrTypeVariance.INV -> Variance.INVARIANT } - fun deserializeIrTypeArgument(proto: IrKlibProtoBuf.IrTypeArgument) = when (proto.kindCase) { - IrKlibProtoBuf.IrTypeArgument.KindCase.STAR -> IrStarProjectionImpl - IrKlibProtoBuf.IrTypeArgument.KindCase.TYPE -> makeTypeProjection( + fun deserializeIrTypeArgument(proto: KotlinIr.IrTypeArgument) = when (proto.kindCase) { + STAR -> IrStarProjectionImpl + TYPE -> makeTypeProjection( deserializeIrType(proto.type.type), deserializeIrTypeVariance(proto.type.variance) ) else -> TODO("Unexpected projection kind") } - fun deserializeAnnotations(annotations: IrKlibProtoBuf.Annotations): List { + fun deserializeAnnotations(annotations: KotlinIr.Annotations): List { return annotations.annotationList.map { deserializeCall(it, 0, 0, builtIns.unitType) // TODO: need a proper deserialization here } } - fun deserializeSimpleType(proto: IrKlibProtoBuf.IrSimpleType): IrSimpleType { + open fun getPrimitiveTypeOrNull(symbol: IrClassifierSymbol, hasQuestionMark: Boolean): IrSimpleType? = null + + fun deserializeSimpleType(proto: KotlinIr.IrSimpleType): IrSimpleType { val symbol = deserializeIrSymbol(proto.classifier) as? IrClassifierSymbol - //?: error("could not convert sym to ClassifierSym ${proto.classifier.kind} ${proto.classifier.uniqId.index} ${proto.classifier.uniqId.isLocal}") ?: error("could not convert sym to ClassifierSymbol") logger.log { "deserializeSimpleType: symbol=$symbol" } - val result = builtIns.getPrimitiveTypeOrNullByDescriptor(symbol.descriptor, proto.hasQuestionMark) ?: run { + val result = getPrimitiveTypeOrNull(symbol, proto.hasQuestionMark) ?: run { val arguments = proto.argumentList.map { deserializeIrTypeArgument(it) } val annotations = deserializeAnnotations(proto.annotations) IrSimpleTypeImpl( @@ -105,17 +115,17 @@ abstract class IrModuleDeserializer( } - fun deserializeDynamicType(proto: IrKlibProtoBuf.IrDynamicType): IrDynamicType { + fun deserializeDynamicType(proto: KotlinIr.IrDynamicType): IrDynamicType { val annotations = deserializeAnnotations(proto.annotations) return IrDynamicTypeImpl(null, annotations, Variance.INVARIANT) } - fun deserializeErrorType(proto: IrKlibProtoBuf.IrErrorType): IrErrorType { + fun deserializeErrorType(proto: KotlinIr.IrErrorType): IrErrorType { val annotations = deserializeAnnotations(proto.annotations) return IrErrorTypeImpl(null, annotations, Variance.INVARIANT) } - fun deserializeIrTypeData(proto: IrKlibProtoBuf.IrType): IrType { + fun deserializeIrTypeData(proto: KotlinIr.IrType): IrType { return when (proto.kindCase) { SIMPLE -> deserializeSimpleType(proto.simple) DYNAMIC -> deserializeDynamicType(proto.dynamic) @@ -127,7 +137,7 @@ abstract class IrModuleDeserializer( /* -------------------------------------------------------------- */ private fun deserializeBlockBody( - proto: IrKlibProtoBuf.IrBlockBody, + proto: KotlinIr.IrBlockBody, start: Int, end: Int ): IrBlockBody { @@ -141,7 +151,7 @@ abstract class IrModuleDeserializer( return IrBlockBodyImpl(start, end, statements) } - private fun deserializeBranch(proto: IrKlibProtoBuf.IrBranch, start: Int, end: Int): IrBranch { + private fun deserializeBranch(proto: KotlinIr.IrBranch, start: Int, end: Int): IrBranch { val condition = deserializeExpression(proto.condition) val result = deserializeExpression(proto.result) @@ -149,7 +159,7 @@ abstract class IrModuleDeserializer( return IrBranchImpl(start, end, condition, result) } - private fun deserializeCatch(proto: IrKlibProtoBuf.IrCatch, start: Int, end: Int): IrCatch { + private fun deserializeCatch(proto: KotlinIr.IrCatch, start: Int, end: Int): IrCatch { val catchParameter = deserializeDeclaration(proto.catchParameter, null) as IrVariable // TODO: we need a proper parent here val result = deserializeExpression(proto.result) @@ -158,15 +168,15 @@ abstract class IrModuleDeserializer( return catch } - private fun deserializeSyntheticBody(proto: IrKlibProtoBuf.IrSyntheticBody, start: Int, end: Int): IrSyntheticBody { + private fun deserializeSyntheticBody(proto: KotlinIr.IrSyntheticBody, start: Int, end: Int): IrSyntheticBody { val kind = when (proto.kind) { - IrKlibProtoBuf.IrSyntheticBodyKind.ENUM_VALUES -> IrSyntheticBodyKind.ENUM_VALUES - IrKlibProtoBuf.IrSyntheticBodyKind.ENUM_VALUEOF -> IrSyntheticBodyKind.ENUM_VALUEOF + KotlinIr.IrSyntheticBodyKind.ENUM_VALUES -> IrSyntheticBodyKind.ENUM_VALUES + KotlinIr.IrSyntheticBodyKind.ENUM_VALUEOF -> IrSyntheticBodyKind.ENUM_VALUEOF } return IrSyntheticBodyImpl(start, end, kind) } - private fun deserializeStatement(proto: IrKlibProtoBuf.IrStatement): IrElement { + private fun deserializeStatement(proto: KotlinIr.IrStatement): IrElement { val start = proto.coordinates.startOffset val end = proto.coordinates.endOffset val element = when (proto.statementCase) { @@ -191,7 +201,7 @@ abstract class IrModuleDeserializer( return element } - private fun deserializeBlock(proto: IrKlibProtoBuf.IrBlock, start: Int, end: Int, type: IrType): IrBlock { + private fun deserializeBlock(proto: KotlinIr.IrBlock, start: Int, end: Int, type: IrType): IrBlock { val statements = mutableListOf() val statementProtos = proto.statementList statementProtos.forEach { @@ -203,7 +213,7 @@ abstract class IrModuleDeserializer( return IrBlockImpl(start, end, type, isLambdaOrigin, statements) } - private fun deserializeMemberAccessCommon(access: IrMemberAccessExpression, proto: IrKlibProtoBuf.MemberAccessCommon) { + private fun deserializeMemberAccessCommon(access: IrMemberAccessExpression, proto: KotlinIr.MemberAccessCommon) { proto.valueArgumentList.mapIndexed { i, arg -> if (arg.hasExpression()) { @@ -225,7 +235,7 @@ abstract class IrModuleDeserializer( } private fun deserializeClassReference( - proto: IrKlibProtoBuf.IrClassReference, + proto: KotlinIr.IrClassReference, start: Int, end: Int, type: IrType @@ -236,7 +246,7 @@ abstract class IrModuleDeserializer( return IrClassReferenceImpl(start, end, type, symbol, classType) } - private fun deserializeCall(proto: IrKlibProtoBuf.IrCall, start: Int, end: Int, type: IrType): IrCall { + private fun deserializeCall(proto: KotlinIr.IrCall, start: Int, end: Int, type: IrType): IrCall { val symbol = deserializeIrSymbol(proto.symbol) as IrFunctionSymbol val superSymbol = if (proto.hasSuper()) { @@ -244,7 +254,7 @@ abstract class IrModuleDeserializer( } else null val call: IrCall = when (proto.kind) { - IrKlibProtoBuf.IrCall.Primitive.NOT_PRIMITIVE -> + KotlinIr.IrCall.Primitive.NOT_PRIMITIVE -> // TODO: implement the last three args here. IrCallImpl( start, end, type, @@ -253,11 +263,11 @@ abstract class IrModuleDeserializer( proto.memberAccess.valueArgumentList.size, null, superSymbol ) - IrKlibProtoBuf.IrCall.Primitive.NULLARY -> + KotlinIr.IrCall.Primitive.NULLARY -> IrNullaryPrimitiveImpl(start, end, type, null, symbol) - IrKlibProtoBuf.IrCall.Primitive.UNARY -> + KotlinIr.IrCall.Primitive.UNARY -> IrUnaryPrimitiveImpl(start, end, type, null, symbol) - IrKlibProtoBuf.IrCall.Primitive.BINARY -> + KotlinIr.IrCall.Primitive.BINARY -> IrBinaryPrimitiveImpl(start, end, type, null, symbol) else -> TODO("Unexpected primitive IrCall.") } @@ -265,7 +275,7 @@ abstract class IrModuleDeserializer( return call } - private fun deserializeComposite(proto: IrKlibProtoBuf.IrComposite, start: Int, end: Int, type: IrType): IrComposite { + private fun deserializeComposite(proto: KotlinIr.IrComposite, start: Int, end: Int, type: IrType): IrComposite { val statements = mutableListOf() val statementProtos = proto.statementList statementProtos.forEach { @@ -275,7 +285,7 @@ abstract class IrModuleDeserializer( } private fun deserializeDelegatingConstructorCall( - proto: IrKlibProtoBuf.IrDelegatingConstructorCall, + proto: KotlinIr.IrDelegatingConstructorCall, start: Int, end: Int ): IrDelegatingConstructorCall { @@ -296,7 +306,7 @@ abstract class IrModuleDeserializer( fun deserializeEnumConstructorCall( - proto: IrKlibProtoBuf.IrEnumConstructorCall, + proto: KotlinIr.IrEnumConstructorCall, start: Int, end: Int, type: IrType @@ -316,7 +326,7 @@ abstract class IrModuleDeserializer( private fun deserializeFunctionReference( - proto: IrKlibProtoBuf.IrFunctionReference, + proto: KotlinIr.IrFunctionReference, start: Int, end: Int, type: IrType ): IrFunctionReference { @@ -336,12 +346,12 @@ abstract class IrModuleDeserializer( return callable } - private fun deserializeGetClass(proto: IrKlibProtoBuf.IrGetClass, start: Int, end: Int, type: IrType): IrGetClass { + private fun deserializeGetClass(proto: KotlinIr.IrGetClass, start: Int, end: Int, type: IrType): IrGetClass { val argument = deserializeExpression(proto.argument) return IrGetClassImpl(start, end, type, argument) } - private fun deserializeGetField(proto: IrKlibProtoBuf.IrGetField, start: Int, end: Int, type: IrType): IrGetField { + private fun deserializeGetField(proto: KotlinIr.IrGetField, start: Int, end: Int, type: IrType): IrGetField { val access = proto.fieldAccess val symbol = deserializeIrSymbol(access.symbol) as IrFieldSymbol val superQualifier = if (access.hasSuper()) { @@ -354,24 +364,24 @@ abstract class IrModuleDeserializer( return IrGetFieldImpl(start, end, symbol, type, receiver, null, superQualifier) } - private fun deserializeGetValue(proto: IrKlibProtoBuf.IrGetValue, start: Int, end: Int, type: IrType): IrGetValue { + private fun deserializeGetValue(proto: KotlinIr.IrGetValue, start: Int, end: Int, type: IrType): IrGetValue { val symbol = deserializeIrSymbol(proto.symbol) as IrValueSymbol // TODO: origin! return IrGetValueImpl(start, end, type, symbol, null) } - private fun deserializeGetEnumValue(proto: IrKlibProtoBuf.IrGetEnumValue, start: Int, end: Int, type: IrType): IrGetEnumValue { + private fun deserializeGetEnumValue(proto: KotlinIr.IrGetEnumValue, start: Int, end: Int, type: IrType): IrGetEnumValue { val symbol = deserializeIrSymbol(proto.symbol) as IrEnumEntrySymbol return IrGetEnumValueImpl(start, end, type, symbol) } - private fun deserializeGetObject(proto: IrKlibProtoBuf.IrGetObject, start: Int, end: Int, type: IrType): IrGetObjectValue { + private fun deserializeGetObject(proto: KotlinIr.IrGetObject, start: Int, end: Int, type: IrType): IrGetObjectValue { val symbol = deserializeIrSymbol(proto.symbol) as IrClassSymbol return IrGetObjectValueImpl(start, end, type, symbol) } private fun deserializeInstanceInitializerCall( - proto: IrKlibProtoBuf.IrInstanceInitializerCall, + proto: KotlinIr.IrInstanceInitializerCall, start: Int, end: Int ): IrInstanceInitializerCall { @@ -382,7 +392,7 @@ abstract class IrModuleDeserializer( private val getterToPropertyDescriptorMap = mutableMapOf() private fun deserializePropertyReference( - proto: IrKlibProtoBuf.IrPropertyReference, + proto: KotlinIr.IrPropertyReference, start: Int, end: Int, type: IrType ): IrPropertyReference { @@ -409,13 +419,13 @@ abstract class IrModuleDeserializer( return callable } - private fun deserializeReturn(proto: IrKlibProtoBuf.IrReturn, start: Int, end: Int, type: IrType): IrReturn { + private fun deserializeReturn(proto: KotlinIr.IrReturn, start: Int, end: Int, type: IrType): IrReturn { val symbol = deserializeIrSymbol(proto.returnTarget) as IrReturnTargetSymbol val value = deserializeExpression(proto.value) return IrReturnImpl(start, end, builtIns.nothingType, symbol, value) } - private fun deserializeSetField(proto: IrKlibProtoBuf.IrSetField, start: Int, end: Int): IrSetField { + private fun deserializeSetField(proto: KotlinIr.IrSetField, start: Int, end: Int): IrSetField { val access = proto.fieldAccess val symbol = deserializeIrSymbol(access.symbol) as IrFieldSymbol val superQualifier = if (access.hasSuper()) { @@ -429,19 +439,19 @@ abstract class IrModuleDeserializer( return IrSetFieldImpl(start, end, symbol, receiver, value, builtIns.unitType, null, superQualifier) } - private fun deserializeSetVariable(proto: IrKlibProtoBuf.IrSetVariable, start: Int, end: Int): IrSetVariable { + private fun deserializeSetVariable(proto: KotlinIr.IrSetVariable, start: Int, end: Int): IrSetVariable { val symbol = deserializeIrSymbol(proto.symbol) as IrVariableSymbol val value = deserializeExpression(proto.value) return IrSetVariableImpl(start, end, builtIns.unitType, symbol, value, null) } - private fun deserializeSpreadElement(proto: IrKlibProtoBuf.IrSpreadElement): IrSpreadElement { + private fun deserializeSpreadElement(proto: KotlinIr.IrSpreadElement): IrSpreadElement { val expression = deserializeExpression(proto.expression) return IrSpreadElementImpl(proto.coordinates.startOffset, proto.coordinates.endOffset, expression) } private fun deserializeStringConcat( - proto: IrKlibProtoBuf.IrStringConcat, + proto: KotlinIr.IrStringConcat, start: Int, end: Int, type: IrType @@ -455,11 +465,11 @@ abstract class IrModuleDeserializer( return IrStringConcatenationImpl(start, end, type, arguments) } - private fun deserializeThrow(proto: IrKlibProtoBuf.IrThrow, start: Int, end: Int, type: IrType): IrThrowImpl { + private fun deserializeThrow(proto: KotlinIr.IrThrow, start: Int, end: Int, type: IrType): IrThrowImpl { return IrThrowImpl(start, end, builtIns.nothingType, deserializeExpression(proto.value)) } - private fun deserializeTry(proto: IrKlibProtoBuf.IrTry, start: Int, end: Int, type: IrType): IrTryImpl { + private fun deserializeTry(proto: KotlinIr.IrTry, start: Int, end: Int, type: IrType): IrTryImpl { val result = deserializeExpression(proto.result) val catches = mutableListOf() proto.catchList.forEach { @@ -470,28 +480,28 @@ abstract class IrModuleDeserializer( return IrTryImpl(start, end, type, result, catches, finallyExpression) } - private fun deserializeTypeOperator(operator: IrKlibProtoBuf.IrTypeOperator) = when (operator) { - IrKlibProtoBuf.IrTypeOperator.CAST + private fun deserializeTypeOperator(operator: KotlinIr.IrTypeOperator) = when (operator) { + KotlinIr.IrTypeOperator.CAST -> IrTypeOperator.CAST - IrKlibProtoBuf.IrTypeOperator.IMPLICIT_CAST + KotlinIr.IrTypeOperator.IMPLICIT_CAST -> IrTypeOperator.IMPLICIT_CAST - IrKlibProtoBuf.IrTypeOperator.IMPLICIT_NOTNULL + KotlinIr.IrTypeOperator.IMPLICIT_NOTNULL -> IrTypeOperator.IMPLICIT_NOTNULL - IrKlibProtoBuf.IrTypeOperator.IMPLICIT_COERCION_TO_UNIT + KotlinIr.IrTypeOperator.IMPLICIT_COERCION_TO_UNIT -> IrTypeOperator.IMPLICIT_COERCION_TO_UNIT - IrKlibProtoBuf.IrTypeOperator.IMPLICIT_INTEGER_COERCION + KotlinIr.IrTypeOperator.IMPLICIT_INTEGER_COERCION -> IrTypeOperator.IMPLICIT_INTEGER_COERCION - IrKlibProtoBuf.IrTypeOperator.SAFE_CAST + KotlinIr.IrTypeOperator.SAFE_CAST -> IrTypeOperator.SAFE_CAST - IrKlibProtoBuf.IrTypeOperator.INSTANCEOF + KotlinIr.IrTypeOperator.INSTANCEOF -> IrTypeOperator.INSTANCEOF - IrKlibProtoBuf.IrTypeOperator.NOT_INSTANCEOF + KotlinIr.IrTypeOperator.NOT_INSTANCEOF -> IrTypeOperator.NOT_INSTANCEOF - IrKlibProtoBuf.IrTypeOperator.SAM_CONVERSION + KotlinIr.IrTypeOperator.SAM_CONVERSION -> IrTypeOperator.SAM_CONVERSION } - private fun deserializeTypeOp(proto: IrKlibProtoBuf.IrTypeOp, start: Int, end: Int, type: IrType): IrTypeOperatorCall { + private fun deserializeTypeOp(proto: KotlinIr.IrTypeOp, start: Int, end: Int, type: IrType): IrTypeOperatorCall { val operator = deserializeTypeOperator(proto.operator) val operand = deserializeIrType(proto.operand)//.brokenIr val argument = deserializeExpression(proto.argument) @@ -501,7 +511,7 @@ abstract class IrModuleDeserializer( } } - private fun deserializeVararg(proto: IrKlibProtoBuf.IrVararg, start: Int, end: Int, type: IrType): IrVararg { + private fun deserializeVararg(proto: KotlinIr.IrVararg, start: Int, end: Int, type: IrType): IrVararg { val elementType = deserializeIrType(proto.elementType) val elements = mutableListOf() @@ -511,18 +521,18 @@ abstract class IrModuleDeserializer( return IrVarargImpl(start, end, type, elementType, elements) } - private fun deserializeVarargElement(element: IrKlibProtoBuf.IrVarargElement): IrVarargElement { + private fun deserializeVarargElement(element: KotlinIr.IrVarargElement): IrVarargElement { return when (element.varargElementCase) { - IrKlibProtoBuf.IrVarargElement.VarargElementCase.EXPRESSION + VarargElementCase.EXPRESSION -> deserializeExpression(element.expression) - IrKlibProtoBuf.IrVarargElement.VarargElementCase.SPREAD_ELEMENT + VarargElementCase.SPREAD_ELEMENT -> deserializeSpreadElement(element.spreadElement) else -> TODO("Unexpected vararg element") } } - private fun deserializeWhen(proto: IrKlibProtoBuf.IrWhen, start: Int, end: Int, type: IrType): IrWhen { + private fun deserializeWhen(proto: KotlinIr.IrWhen, start: Int, end: Int, type: IrType): IrWhen { val branches = mutableListOf() proto.branchList.forEach { @@ -533,12 +543,7 @@ abstract class IrModuleDeserializer( return IrWhenImpl(start, end, type, null, branches) } - private val loopIndex = mutableMapOf() - - private fun deserializeLoop(proto: IrKlibProtoBuf.Loop, loop: IrLoopBase): IrLoopBase { - val loopId = proto.loopId - loopIndex.getOrPut(loopId) { loop } - + private fun deserializeLoop(proto: KotlinIr.Loop, loop: IrLoopBase): IrLoopBase { val label = if (proto.hasLabel()) deserializeString(proto.label) else null val body = if (proto.hasBody()) deserializeExpression(proto.body) else null val condition = deserializeExpression(proto.condition) @@ -550,96 +555,88 @@ abstract class IrModuleDeserializer( return loop } - private fun deserializeDoWhile(proto: IrKlibProtoBuf.IrDoWhile, start: Int, end: Int, type: IrType): IrDoWhileLoop { - // we create the loop before deserializing the body, so that - // IrBreak statements have something to put into 'loop' field. - val loop = IrDoWhileLoopImpl(start, end, type, null) - deserializeLoop(proto.loop, loop) - return loop - } + // we create the loop before deserializing the body, so that + // IrBreak statements have something to put into 'loop' field. + private fun deserializeDoWhile(proto: KotlinIr.IrDoWhile, start: Int, end: Int, type: IrType) = + deserializeLoop(proto.loop, deserializeLoopHeader(proto.loop.loopId) { IrDoWhileLoopImpl(start, end, type, null) }) - private fun deserializeWhile(proto: IrKlibProtoBuf.IrWhile, start: Int, end: Int, type: IrType): IrWhileLoop { - // we create the loop before deserializing the body, so that - // IrBreak statements have something to put into 'loop' field. - val loop = IrWhileLoopImpl(start, end, type, null) - deserializeLoop(proto.loop, loop) - return loop - } + private fun deserializeWhile(proto: KotlinIr.IrWhile, start: Int, end: Int, type: IrType) = + deserializeLoop(proto.loop, deserializeLoopHeader(proto.loop.loopId) { IrWhileLoopImpl(start, end, type, null) }) - private fun deserializeDynamicMemberExpression(proto: IrKlibProtoBuf.IrDynamicMemberExpression, start: Int, end: Int, type: IrType) = + private fun deserializeDynamicMemberExpression(proto: KotlinIr.IrDynamicMemberExpression, start: Int, end: Int, type: IrType) = IrDynamicMemberExpressionImpl(start, end, type, deserializeString(proto.memberName), deserializeExpression(proto.receiver)) - private fun deserializeDynamicOperatorExpression(proto: IrKlibProtoBuf.IrDynamicOperatorExpression, start: Int, end: Int, type: IrType) = + private fun deserializeDynamicOperatorExpression(proto: KotlinIr.IrDynamicOperatorExpression, start: Int, end: Int, type: IrType) = IrDynamicOperatorExpressionImpl(start, end, type, deserializeDynamicOperator(proto.operator)).apply { receiver = deserializeExpression(proto.receiver) proto.argumentList.mapTo(arguments) { deserializeExpression(it) } } - private fun deserializeDynamicOperator(operator: IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator) = when (operator) { - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS -> IrDynamicOperator.UNARY_PLUS - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_MINUS -> IrDynamicOperator.UNARY_MINUS + private fun deserializeDynamicOperator(operator: KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator) = when (operator) { + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS -> IrDynamicOperator.UNARY_PLUS + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_MINUS -> IrDynamicOperator.UNARY_MINUS - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCL -> IrDynamicOperator.EXCL + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCL -> IrDynamicOperator.EXCL - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_INCREMENT -> IrDynamicOperator.PREFIX_INCREMENT - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT -> IrDynamicOperator.PREFIX_DECREMENT + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_INCREMENT -> IrDynamicOperator.PREFIX_INCREMENT + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT -> IrDynamicOperator.PREFIX_DECREMENT - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT -> IrDynamicOperator.POSTFIX_INCREMENT - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_DECREMENT -> IrDynamicOperator.POSTFIX_DECREMENT + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT -> IrDynamicOperator.POSTFIX_INCREMENT + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_DECREMENT -> IrDynamicOperator.POSTFIX_DECREMENT - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_PLUS -> IrDynamicOperator.BINARY_PLUS - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_MINUS -> IrDynamicOperator.BINARY_MINUS - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MUL -> IrDynamicOperator.MUL - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.DIV -> IrDynamicOperator.DIV - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MOD -> IrDynamicOperator.MOD + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_PLUS -> IrDynamicOperator.BINARY_PLUS + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_MINUS -> IrDynamicOperator.BINARY_MINUS + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MUL -> IrDynamicOperator.MUL + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIV -> IrDynamicOperator.DIV + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MOD -> IrDynamicOperator.MOD - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.GT -> IrDynamicOperator.GT - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.LT -> IrDynamicOperator.LT - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.GE -> IrDynamicOperator.GE - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.LE -> IrDynamicOperator.LE + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GT -> IrDynamicOperator.GT + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LT -> IrDynamicOperator.LT + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GE -> IrDynamicOperator.GE + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LE -> IrDynamicOperator.LE - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ -> IrDynamicOperator.EQEQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ -> IrDynamicOperator.EXCLEQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ -> IrDynamicOperator.EQEQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ -> IrDynamicOperator.EXCLEQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ -> IrDynamicOperator.EQEQEQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ -> IrDynamicOperator.EXCLEQEQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ -> IrDynamicOperator.EQEQEQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ -> IrDynamicOperator.EXCLEQEQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND -> IrDynamicOperator.ANDAND - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.OROR -> IrDynamicOperator.OROR + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND -> IrDynamicOperator.ANDAND + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.OROR -> IrDynamicOperator.OROR - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQ -> IrDynamicOperator.EQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PLUSEQ -> IrDynamicOperator.PLUSEQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MINUSEQ -> IrDynamicOperator.MINUSEQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MULEQ -> IrDynamicOperator.MULEQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.DIVEQ -> IrDynamicOperator.DIVEQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MODEQ -> IrDynamicOperator.MODEQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQ -> IrDynamicOperator.EQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PLUSEQ -> IrDynamicOperator.PLUSEQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MINUSEQ -> IrDynamicOperator.MINUSEQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MULEQ -> IrDynamicOperator.MULEQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIVEQ -> IrDynamicOperator.DIVEQ + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MODEQ -> IrDynamicOperator.MODEQ - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.ARRAY_ACCESS -> IrDynamicOperator.ARRAY_ACCESS + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ARRAY_ACCESS -> IrDynamicOperator.ARRAY_ACCESS - IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.INVOKE -> IrDynamicOperator.INVOKE + KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.INVOKE -> IrDynamicOperator.INVOKE } - private fun deserializeBreak(proto: IrKlibProtoBuf.IrBreak, start: Int, end: Int, type: IrType): IrBreak { + private fun deserializeBreak(proto: KotlinIr.IrBreak, start: Int, end: Int, type: IrType): IrBreak { val label = if (proto.hasLabel()) deserializeString(proto.label) else null val loopId = proto.loopId - val loop = loopIndex[loopId]!! + val loop = deserializeLoopHeader(loopId) { error("break clause before loop header") } val irBreak = IrBreakImpl(start, end, type, loop) irBreak.label = label return irBreak } - private fun deserializeContinue(proto: IrKlibProtoBuf.IrContinue, start: Int, end: Int, type: IrType): IrContinue { + private fun deserializeContinue(proto: KotlinIr.IrContinue, start: Int, end: Int, type: IrType): IrContinue { val label = if (proto.hasLabel()) deserializeString(proto.label) else null val loopId = proto.loopId - val loop = loopIndex[loopId]!! + val loop = deserializeLoopHeader(loopId) { error("continue clause before loop header") } val irContinue = IrContinueImpl(start, end, type, loop) irContinue.label = label return irContinue } - private fun deserializeConst(proto: IrKlibProtoBuf.IrConst, start: Int, end: Int, type: IrType): IrExpression = + private fun deserializeConst(proto: KotlinIr.IrConst, start: Int, end: Int, type: IrType): IrExpression = when (proto.valueCase) { NULL -> IrConstImpl.constNull(start, end, type) @@ -665,7 +662,7 @@ abstract class IrModuleDeserializer( -> error("Const deserialization error: ${proto.valueCase} ") } - private fun deserializeOperation(proto: IrKlibProtoBuf.IrOperation, start: Int, end: Int, type: IrType): IrExpression = + private fun deserializeOperation(proto: KotlinIr.IrOperation, start: Int, end: Int, type: IrType): IrExpression = when (proto.operationCase) { BLOCK -> deserializeBlock(proto.block, start, end, type) @@ -731,7 +728,7 @@ abstract class IrModuleDeserializer( -> error("Expression deserialization not implemented: ${proto.operationCase}") } - private fun deserializeExpression(proto: IrKlibProtoBuf.IrExpression): IrExpression { + private fun deserializeExpression(proto: KotlinIr.IrExpression): IrExpression { val start = proto.coordinates.startOffset val end = proto.coordinates.endOffset val type = deserializeIrType(proto.type) @@ -743,13 +740,13 @@ abstract class IrModuleDeserializer( } private fun deserializeIrTypeParameter( - proto: IrKlibProtoBuf.IrTypeParameter, + proto: KotlinIr.IrTypeParameter, start: Int, end: Int, origin: IrDeclarationOrigin ): IrTypeParameter { val symbol = deserializeIrSymbol(proto.symbol) as IrTypeParameterSymbol - val name = Name.identifier(deserializeString(proto.name)) + val name = deserializeName(proto.name) val variance = deserializeIrTypeVariance(proto.variance) val parameter = symbolTable.declareGlobalTypeParameter(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irrelevantOrigin, @@ -765,7 +762,7 @@ abstract class IrModuleDeserializer( } private fun deserializeIrTypeParameterContainer( - proto: IrKlibProtoBuf.IrTypeParameterContainer, + proto: KotlinIr.IrTypeParameterContainer, parent: IrDeclarationParent ): List { return proto.typeParameterList.map { @@ -776,17 +773,17 @@ abstract class IrModuleDeserializer( } // TODO: we need proper start, end and origin here? } - private fun deserializeClassKind(kind: IrKlibProtoBuf.ClassKind) = when (kind) { - IrKlibProtoBuf.ClassKind.CLASS -> ClassKind.CLASS - IrKlibProtoBuf.ClassKind.INTERFACE -> ClassKind.INTERFACE - IrKlibProtoBuf.ClassKind.ENUM_CLASS -> ClassKind.ENUM_CLASS - IrKlibProtoBuf.ClassKind.ENUM_ENTRY -> ClassKind.ENUM_ENTRY - IrKlibProtoBuf.ClassKind.ANNOTATION_CLASS -> ClassKind.ANNOTATION_CLASS - IrKlibProtoBuf.ClassKind.OBJECT -> ClassKind.OBJECT + private fun deserializeClassKind(kind: KotlinIr.ClassKind) = when (kind) { + KotlinIr.ClassKind.CLASS -> ClassKind.CLASS + KotlinIr.ClassKind.INTERFACE -> ClassKind.INTERFACE + KotlinIr.ClassKind.ENUM_CLASS -> ClassKind.ENUM_CLASS + KotlinIr.ClassKind.ENUM_ENTRY -> ClassKind.ENUM_ENTRY + KotlinIr.ClassKind.ANNOTATION_CLASS -> ClassKind.ANNOTATION_CLASS + KotlinIr.ClassKind.OBJECT -> ClassKind.OBJECT } private fun deserializeIrValueParameter( - proto: IrKlibProtoBuf.IrValueParameter, + proto: KotlinIr.IrValueParameter, start: Int, end: Int, origin: IrDeclarationOrigin @@ -798,7 +795,7 @@ abstract class IrModuleDeserializer( IrValueParameterImpl( start, end, origin, paramSymbol, - deserializeString(proto.name).let { if (paramSymbol.descriptor is ReceiverParameterDescriptor) Name.special(it) else Name.identifier(it) }, + deserializeName(proto.name), proto.index, deserializeIrType(proto.type), varargElementType, @@ -814,7 +811,7 @@ abstract class IrModuleDeserializer( return parameter } - private fun deserializeIrClass(proto: IrKlibProtoBuf.IrClass, start: Int, end: Int, origin: IrDeclarationOrigin): IrClass { + private fun deserializeIrClass(proto: KotlinIr.IrClass, start: Int, end: Int, origin: IrDeclarationOrigin): IrClass { val symbol = deserializeIrSymbol(proto.symbol) as IrClassSymbol @@ -824,7 +821,7 @@ abstract class IrModuleDeserializer( IrClassImpl( start, end, origin, it, - deserializeString(proto.name).let { if (it.startsWith('<')) Name.special(it) else Name.identifier(it) }, + deserializeName(proto.name), deserializeClassKind(proto.kind), deserializeVisibility(proto.visibility), modality, @@ -854,7 +851,7 @@ abstract class IrModuleDeserializer( } private fun deserializeIrFunctionBase( - base: IrKlibProtoBuf.IrFunctionBase, + base: KotlinIr.IrFunctionBase, function: IrFunctionBase, start: Int, end: Int, @@ -878,8 +875,8 @@ abstract class IrModuleDeserializer( } private fun deserializeIrFunction( - proto: IrKlibProtoBuf.IrFunction, - start: Int, end: Int, origin: IrDeclarationOrigin, isAccessor: Boolean + proto: KotlinIr.IrFunction, + start: Int, end: Int, origin: IrDeclarationOrigin ): IrSimpleFunction { logger.log { "### deserializing IrFunction ${proto.base.name}" } @@ -889,7 +886,7 @@ abstract class IrModuleDeserializer( symbol.descriptor, { IrFunctionImpl( start, end, origin, it, - deserializeString(proto.base.name).let { if (isAccessor) Name.special(it) else Name.identifier(it) }, + deserializeName(proto.base.name), deserializeVisibility(proto.base.visibility), deserializeModality(proto.modality), deserializeIrType(proto.base.returnType), @@ -910,7 +907,7 @@ abstract class IrModuleDeserializer( } private fun deserializeIrVariable( - proto: IrKlibProtoBuf.IrVariable, + proto: KotlinIr.IrVariable, start: Int, end: Int, origin: IrDeclarationOrigin ): IrVariable { @@ -926,7 +923,7 @@ abstract class IrModuleDeserializer( end, origin, symbol, - Name.identifier(deserializeString(proto.name)), + deserializeName(proto.name), type, proto.isVar, proto.isConst, @@ -937,7 +934,7 @@ abstract class IrModuleDeserializer( } private fun deserializeIrEnumEntry( - proto: IrKlibProtoBuf.IrEnumEntry, + proto: KotlinIr.IrEnumEntry, start: Int, end: Int, origin: IrDeclarationOrigin ): IrEnumEntry { val symbol = deserializeIrSymbol(proto.symbol) as IrEnumEntrySymbol @@ -948,7 +945,7 @@ abstract class IrModuleDeserializer( irrelevantOrigin, symbol.descriptor ) { - IrEnumEntryImpl(start, end, origin, it, Name.identifier(deserializeString(proto.name))) + IrEnumEntryImpl(start, end, origin, it, deserializeName(proto.name)) } if (proto.hasCorrespondingClass()) { @@ -962,7 +959,7 @@ abstract class IrModuleDeserializer( } private fun deserializeIrAnonymousInit( - proto: IrKlibProtoBuf.IrAnonymousInit, + proto: KotlinIr.IrAnonymousInit, start: Int, end: Int, origin: IrDeclarationOrigin @@ -973,7 +970,7 @@ abstract class IrModuleDeserializer( return initializer } - private fun deserializeVisibility(value: IrKlibProtoBuf.Visibility): Visibility { // TODO: switch to enum + private fun deserializeVisibility(value: KotlinIr.Visibility): Visibility { // TODO: switch to enum return when (deserializeString(value.name)) { "public" -> Visibilities.PUBLIC "private" -> Visibilities.PRIVATE @@ -987,7 +984,7 @@ abstract class IrModuleDeserializer( } private fun deserializeIrConstructor( - proto: IrKlibProtoBuf.IrConstructor, + proto: KotlinIr.IrConstructor, start: Int, end: Int, origin: IrDeclarationOrigin @@ -999,7 +996,7 @@ abstract class IrModuleDeserializer( IrConstructorImpl( start, end, origin, it, - Name.special(deserializeString(proto.base.name)), + deserializeName(proto.base.name), deserializeVisibility(proto.base.visibility), deserializeIrType(proto.base.returnType), proto.base.isInline, @@ -1013,7 +1010,7 @@ abstract class IrModuleDeserializer( return constructor } - private fun deserializeIrField(proto: IrKlibProtoBuf.IrField, start: Int, end: Int, origin: IrDeclarationOrigin): IrField { + private fun deserializeIrField(proto: KotlinIr.IrField, start: Int, end: Int, origin: IrDeclarationOrigin): IrField { val symbol = deserializeIrSymbol(proto.symbol) as IrFieldSymbol val type = deserializeIrType(proto.type) @@ -1025,7 +1022,7 @@ abstract class IrModuleDeserializer( { IrFieldImpl( start, end, origin, it, - Name.identifier(deserializeString(proto.name)), + deserializeName(proto.name), type, deserializeVisibility(proto.visibility), proto.isFinal, @@ -1041,23 +1038,23 @@ abstract class IrModuleDeserializer( return field } - private fun deserializeModality(modality: IrKlibProtoBuf.ModalityKind) = when (modality) { - IrKlibProtoBuf.ModalityKind.OPEN_MODALITY -> Modality.OPEN - IrKlibProtoBuf.ModalityKind.SEALED_MODALITY -> Modality.SEALED - IrKlibProtoBuf.ModalityKind.FINAL_MODALITY -> Modality.FINAL - IrKlibProtoBuf.ModalityKind.ABSTRACT_MODALITY -> Modality.ABSTRACT + private fun deserializeModality(modality: KotlinIr.ModalityKind) = when (modality) { + KotlinIr.ModalityKind.OPEN_MODALITY -> Modality.OPEN + KotlinIr.ModalityKind.SEALED_MODALITY -> Modality.SEALED + KotlinIr.ModalityKind.FINAL_MODALITY -> Modality.FINAL + KotlinIr.ModalityKind.ABSTRACT_MODALITY -> Modality.ABSTRACT } private fun deserializeIrProperty( - proto: IrKlibProtoBuf.IrProperty, + proto: KotlinIr.IrProperty, start: Int, end: Int, origin: IrDeclarationOrigin ): IrProperty { val backingField = if (proto.hasBackingField()) deserializeIrField(proto.backingField, start, end, origin) else null - val getter = if (proto.hasGetter()) deserializeIrFunction(proto.getter, start, end, origin, true) else null - val setter = if (proto.hasSetter()) deserializeIrFunction(proto.setter, start, end, origin, true) else null + val getter = if (proto.hasGetter()) deserializeIrFunction(proto.getter, start, end, origin) else null + val setter = if (proto.hasSetter()) deserializeIrFunction(proto.setter, start, end, origin) else null backingField?.let { (it.descriptor as? WrappedFieldDescriptor)?.bind(it) } getter?.let { (it.descriptor as? WrappedSimpleFunctionDescriptor)?.bind(it) } @@ -1073,7 +1070,7 @@ abstract class IrModuleDeserializer( val property = IrPropertyImpl( start, end, origin, descriptor, - Name.identifier(deserializeString(proto.name)), + deserializeName(proto.name), deserializeVisibility(proto.visibility), deserializeModality(proto.modality), proto.isVar, @@ -1097,7 +1094,7 @@ abstract class IrModuleDeserializer( } private fun deserializeIrTypeAlias( - proto: IrKlibProtoBuf.IrTypeAlias, + proto: KotlinIr.IrTypeAlias, start: Int, end: Int, origin: IrDeclarationOrigin @@ -1109,9 +1106,9 @@ abstract class IrModuleDeserializer( IrDeclarationOrigin::class.nestedClasses.toList() + DeclarationFactory.FIELD_FOR_OUTER_THIS::class val originIndex = allKnownOrigins.map { it.objectInstance as IrDeclarationOriginImpl }.associateBy { it.name } val irrelevantOrigin = object : IrDeclarationOriginImpl("irrelevant") {} - fun deserializeIrDeclarationOrigin(proto: IrKlibProtoBuf.IrDeclarationOrigin) = originIndex[deserializeString(proto.custom)]!! + fun deserializeIrDeclarationOrigin(proto: KotlinIr.IrDeclarationOrigin) = originIndex[deserializeString(proto.custom)]!! - protected fun deserializeDeclaration(proto: IrKlibProtoBuf.IrDeclaration, parent: IrDeclarationParent?): IrDeclaration { + protected fun deserializeDeclaration(proto: KotlinIr.IrDeclaration, parent: IrDeclarationParent?): IrDeclaration { val start = proto.coordinates.startOffset val end = proto.coordinates.endOffset @@ -1129,7 +1126,7 @@ abstract class IrModuleDeserializer( IR_CLASS -> deserializeIrClass(declarator.irClass, start, end, origin) IR_FUNCTION - -> deserializeIrFunction(declarator.irFunction, start, end, origin, false) + -> deserializeIrFunction(declarator.irFunction, start, end, origin) IR_PROPERTY -> deserializeIrProperty(declarator.irProperty, start, end, origin) IR_TYPE_ALIAS diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleSerializer.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleSerializer.kt similarity index 66% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleSerializer.kt rename to compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleSerializer.kt index d32a62d37fb..4fb32519d33 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleSerializer.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleSerializer.kt @@ -3,10 +3,12 @@ * that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +package org.jetbrains.kotlin.backend.common.serialization import org.jetbrains.kotlin.backend.common.LoggingContext import org.jetbrains.kotlin.backend.common.ir.ir2string +import org.jetbrains.kotlin.backend.common.library.CombinedIrFileWriter +import org.jetbrains.kotlin.backend.common.library.DeclarationId import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.ClassKind.* import org.jetbrains.kotlin.descriptors.Modality @@ -15,34 +17,38 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.SourceManager import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionBase import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.IrBinaryPrimitiveImpl import org.jetbrains.kotlin.ir.expressions.impl.IrNullaryPrimitiveImpl import org.jetbrains.kotlin.ir.expressions.impl.IrUnaryPrimitiveImpl import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.types.* +import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid +import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid +import org.jetbrains.kotlin.ir.visitors.acceptVoid +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance -internal class IrModuleSerializer( +open class IrModuleSerializer( val logger: LoggingContext, val declarationTable: DeclarationTable, + val mangler: KotlinMangler, val bodiesOnlyForInlines: Boolean = false ) { private val loopIndex = mutableMapOf() private var currentLoopIndex = 0 - val descriptorReferenceSerializer = DescriptorReferenceSerializer(declarationTable, { string -> serializeString(string) }) + val descriptorReferenceSerializer = DescriptorReferenceSerializer(declarationTable, { string -> serializeString(string) }, mangler) // The same symbol can be used multiple times in a module // so use this index to store symbol data only once. val protoSymbolMap = mutableMapOf() - val protoSymbolArray = arrayListOf() + val protoSymbolArray = arrayListOf() // The same type can be used multiple times in a module // so use this index to store type data only once. val protoTypeMap = mutableMapOf() - val protoTypeArray = arrayListOf() + val protoTypeArray = arrayListOf() val protoStringMap = mutableMapOf() val protoStringArray = arrayListOf() @@ -50,22 +56,22 @@ internal class IrModuleSerializer( /* ------- Common fields ---------------------------------------------------- */ private fun serializeIrDeclarationOrigin(origin: IrDeclarationOrigin) = - IrKlibProtoBuf.IrDeclarationOrigin.newBuilder() + KotlinIr.IrDeclarationOrigin.newBuilder() .setCustom(serializeString((origin as IrDeclarationOriginImpl).name)) .build() private fun serializeIrStatementOrigin(origin: IrStatementOrigin) = - IrKlibProtoBuf.IrStatementOrigin.newBuilder() + KotlinIr.IrStatementOrigin.newBuilder() .setName(serializeString((origin as IrStatementOriginImpl).debugName)) .build() private fun serializeVisibility(visibility: Visibility) = - IrKlibProtoBuf.Visibility.newBuilder() + KotlinIr.Visibility.newBuilder() .setName(serializeString(visibility.name)) .build() - private fun serializeCoordinates(start: Int, end: Int): IrKlibProtoBuf.Coordinates { - return IrKlibProtoBuf.Coordinates.newBuilder() + private fun serializeCoordinates(start: Int, end: Int): KotlinIr.Coordinates { + return KotlinIr.Coordinates.newBuilder() .setStartOffset(start) .setEndOffset(end) .build() @@ -73,8 +79,8 @@ internal class IrModuleSerializer( /* ------- Strings ---------------------------------------------------------- */ - fun serializeString(value: String): IrKlibProtoBuf.String { - val proto = IrKlibProtoBuf.String.newBuilder() + fun serializeString(value: String): KotlinIr.String { + val proto = KotlinIr.String.newBuilder() proto.index = protoStringMap.getOrPut(value) { protoStringArray.add(value) protoStringArray.size - 1 @@ -82,44 +88,51 @@ internal class IrModuleSerializer( return proto.build() } + fun serializeName(name: Name): KotlinIr.Name { + val proto = KotlinIr.Name.newBuilder() + .setName(serializeString(name.toString())) + .setIsSpecial(name.isSpecial) + return proto.build() + } + /* ------- IrSymbols -------------------------------------------------------- */ - fun protoSymbolKind(symbol: IrSymbol): IrKlibProtoBuf.IrSymbolKind = when (symbol) { + fun protoSymbolKind(symbol: IrSymbol): KotlinIr.IrSymbolKind = when (symbol) { is IrAnonymousInitializerSymbol -> - IrKlibProtoBuf.IrSymbolKind.ANONYMOUS_INIT_SYMBOL + KotlinIr.IrSymbolKind.ANONYMOUS_INIT_SYMBOL is IrClassSymbol -> - IrKlibProtoBuf.IrSymbolKind.CLASS_SYMBOL + KotlinIr.IrSymbolKind.CLASS_SYMBOL is IrConstructorSymbol -> - IrKlibProtoBuf.IrSymbolKind.CONSTRUCTOR_SYMBOL + KotlinIr.IrSymbolKind.CONSTRUCTOR_SYMBOL is IrTypeParameterSymbol -> - IrKlibProtoBuf.IrSymbolKind.TYPE_PARAMETER_SYMBOL + KotlinIr.IrSymbolKind.TYPE_PARAMETER_SYMBOL is IrEnumEntrySymbol -> - IrKlibProtoBuf.IrSymbolKind.ENUM_ENTRY_SYMBOL + KotlinIr.IrSymbolKind.ENUM_ENTRY_SYMBOL is IrVariableSymbol -> - IrKlibProtoBuf.IrSymbolKind.VARIABLE_SYMBOL + KotlinIr.IrSymbolKind.VARIABLE_SYMBOL is IrValueParameterSymbol -> if (symbol.descriptor is ReceiverParameterDescriptor) // TODO: we use descriptor here. - IrKlibProtoBuf.IrSymbolKind.RECEIVER_PARAMETER_SYMBOL + KotlinIr.IrSymbolKind.RECEIVER_PARAMETER_SYMBOL else - IrKlibProtoBuf.IrSymbolKind.VALUE_PARAMETER_SYMBOL + KotlinIr.IrSymbolKind.VALUE_PARAMETER_SYMBOL is IrSimpleFunctionSymbol -> - IrKlibProtoBuf.IrSymbolKind.FUNCTION_SYMBOL + KotlinIr.IrSymbolKind.FUNCTION_SYMBOL is IrReturnableBlockSymbol -> - IrKlibProtoBuf.IrSymbolKind.RETURNABLE_BLOCK_SYMBOL + KotlinIr.IrSymbolKind.RETURNABLE_BLOCK_SYMBOL is IrFieldSymbol -> if (symbol.owner.correspondingProperty.let { it == null || it.isDelegated }) - IrKlibProtoBuf.IrSymbolKind.STANDALONE_FIELD_SYMBOL + KotlinIr.IrSymbolKind.STANDALONE_FIELD_SYMBOL else - IrKlibProtoBuf.IrSymbolKind.FIELD_SYMBOL + KotlinIr.IrSymbolKind.FIELD_SYMBOL else -> TODO("Unexpected symbol kind: $symbol") } - fun serializeIrSymbolData(symbol: IrSymbol): IrKlibProtoBuf.IrSymbolData { + fun serializeIrSymbolData(symbol: IrSymbol): KotlinIr.IrSymbolData { val declaration = symbol.owner as? IrDeclaration ?: error("Expected IrDeclaration: ${symbol.owner}") - val proto = IrKlibProtoBuf.IrSymbolData.newBuilder() + val proto = KotlinIr.IrSymbolData.newBuilder() proto.kind = protoSymbolKind(symbol) val uniqId = @@ -137,8 +150,8 @@ internal class IrModuleSerializer( return proto.build() } - fun serializeIrSymbol(symbol: IrSymbol): IrKlibProtoBuf.IrSymbol { - val proto = IrKlibProtoBuf.IrSymbol.newBuilder() + fun serializeIrSymbol(symbol: IrSymbol): KotlinIr.IrSymbol { + val proto = KotlinIr.IrSymbol.newBuilder() proto.index = protoSymbolMap.getOrPut(symbol) { protoSymbolArray.add(serializeIrSymbolData(symbol)) protoSymbolArray.size - 1 @@ -150,8 +163,8 @@ internal class IrModuleSerializer( // TODO: we, probably, need a type table. - private fun serializeTypeArguments(call: IrMemberAccessExpression): IrKlibProtoBuf.TypeArguments { - val proto = IrKlibProtoBuf.TypeArguments.newBuilder() + private fun serializeTypeArguments(call: IrMemberAccessExpression): KotlinIr.TypeArguments { + val proto = KotlinIr.TypeArguments.newBuilder() for (i in 0 until call.typeArgumentsCount) { proto.addTypeArgument(serializeIrType(call.getTypeArgument(i)!!)) } @@ -159,29 +172,29 @@ internal class IrModuleSerializer( } fun serializeIrTypeVariance(variance: Variance) = when (variance) { - Variance.IN_VARIANCE -> IrKlibProtoBuf.IrTypeVariance.IN - Variance.OUT_VARIANCE -> IrKlibProtoBuf.IrTypeVariance.OUT - Variance.INVARIANT -> IrKlibProtoBuf.IrTypeVariance.INV + Variance.IN_VARIANCE -> KotlinIr.IrTypeVariance.IN + Variance.OUT_VARIANCE -> KotlinIr.IrTypeVariance.OUT + Variance.INVARIANT -> KotlinIr.IrTypeVariance.INV } - fun serializeAnnotations(annotations: List): IrKlibProtoBuf.Annotations { - val proto = IrKlibProtoBuf.Annotations.newBuilder() + fun serializeAnnotations(annotations: List): KotlinIr.Annotations { + val proto = KotlinIr.Annotations.newBuilder() annotations.forEach { proto.addAnnotation(serializeCall(it)) } return proto.build() } - fun serializeIrTypeProjection(argument: IrTypeProjection) = IrKlibProtoBuf.IrTypeProjection.newBuilder() + fun serializeIrTypeProjection(argument: IrTypeProjection) = KotlinIr.IrTypeProjection.newBuilder() .setVariance(serializeIrTypeVariance(argument.variance)) .setType(serializeIrType(argument.type)) .build() - fun serializeTypeArgument(argument: IrTypeArgument): IrKlibProtoBuf.IrTypeArgument { - val proto = IrKlibProtoBuf.IrTypeArgument.newBuilder() + fun serializeTypeArgument(argument: IrTypeArgument): KotlinIr.IrTypeArgument { + val proto = KotlinIr.IrTypeArgument.newBuilder() when (argument) { is IrStarProjection -> - proto.star = IrKlibProtoBuf.IrStarProjection.newBuilder() + proto.star = KotlinIr.IrStarProjection.newBuilder() .build() // TODO: Do we need a singletone here? Or just an enum? is IrTypeProjection -> proto.type = serializeIrTypeProjection(argument) @@ -190,8 +203,8 @@ internal class IrModuleSerializer( return proto.build() } - fun serializeSimpleType(type: IrSimpleType): IrKlibProtoBuf.IrSimpleType { - val proto = IrKlibProtoBuf.IrSimpleType.newBuilder() + fun serializeSimpleType(type: IrSimpleType): KotlinIr.IrSimpleType { + val proto = KotlinIr.IrSimpleType.newBuilder() .setAnnotations(serializeAnnotations(type.annotations)) .setClassifier(serializeIrSymbol(type.classifier)) .setHasQuestionMark(type.hasQuestionMark) @@ -201,17 +214,17 @@ internal class IrModuleSerializer( return proto.build() } - fun serializeDynamicType(type: IrDynamicType) = IrKlibProtoBuf.IrDynamicType.newBuilder() + fun serializeDynamicType(type: IrDynamicType) = KotlinIr.IrDynamicType.newBuilder() .setAnnotations(serializeAnnotations(type.annotations)) .build() - fun serializeErrorType(type: IrErrorType) = IrKlibProtoBuf.IrErrorType.newBuilder() + fun serializeErrorType(type: IrErrorType) = KotlinIr.IrErrorType.newBuilder() .setAnnotations(serializeAnnotations(type.annotations)) .build() - private fun serializeIrTypeData(type: IrType): IrKlibProtoBuf.IrType { + private fun serializeIrTypeData(type: IrType): KotlinIr.IrType { logger.log { "### serializing IrType: " + type } - val proto = IrKlibProtoBuf.IrType.newBuilder() + val proto = KotlinIr.IrType.newBuilder() when (type) { is IrSimpleType -> proto.simple = serializeSimpleType(type) @@ -273,8 +286,8 @@ internal class IrModuleSerializer( type = (this as? IrTypeProjection)?.type?.toIrTypeKey ) - fun serializeIrType(type: IrType): IrKlibProtoBuf.IrTypeIndex { - val proto = IrKlibProtoBuf.IrTypeIndex.newBuilder() + fun serializeIrType(type: IrType): KotlinIr.IrTypeIndex { + val proto = KotlinIr.IrTypeIndex.newBuilder() val key = type.toIrTypeKey proto.index = protoTypeMap.getOrPut(key) { // println("new type: $type ${(type as? IrSimpleType)?.classifier?.descriptor}${if((type as? IrSimpleType)?.hasQuestionMark ?: false) "?" else ""}") @@ -287,16 +300,16 @@ internal class IrModuleSerializer( /* -------------------------------------------------------------------------- */ - private fun serializeBlockBody(expression: IrBlockBody): IrKlibProtoBuf.IrBlockBody { - val proto = IrKlibProtoBuf.IrBlockBody.newBuilder() + private fun serializeBlockBody(expression: IrBlockBody): KotlinIr.IrBlockBody { + val proto = KotlinIr.IrBlockBody.newBuilder() expression.statements.forEach { proto.addStatement(serializeStatement(it)) } return proto.build() } - private fun serializeBranch(branch: IrBranch): IrKlibProtoBuf.IrBranch { - val proto = IrKlibProtoBuf.IrBranch.newBuilder() + private fun serializeBranch(branch: IrBranch): KotlinIr.IrBranch { + val proto = KotlinIr.IrBranch.newBuilder() proto.condition = serializeExpression(branch.condition) proto.result = serializeExpression(branch.result) @@ -304,11 +317,11 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeBlock(block: IrBlock): IrKlibProtoBuf.IrBlock { + private fun serializeBlock(block: IrBlock): KotlinIr.IrBlock { val isLambdaOrigin = block.origin == IrStatementOrigin.LAMBDA || block.origin == IrStatementOrigin.ANONYMOUS_FUNCTION - val proto = IrKlibProtoBuf.IrBlock.newBuilder() + val proto = KotlinIr.IrBlock.newBuilder() .setIsLambdaOrigin(isLambdaOrigin) block.statements.forEach { proto.addStatement(serializeStatement(it)) @@ -316,42 +329,42 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeComposite(composite: IrComposite): IrKlibProtoBuf.IrComposite { - val proto = IrKlibProtoBuf.IrComposite.newBuilder() + private fun serializeComposite(composite: IrComposite): KotlinIr.IrComposite { + val proto = KotlinIr.IrComposite.newBuilder() composite.statements.forEach { proto.addStatement(serializeStatement(it)) } return proto.build() } - private fun serializeCatch(catch: IrCatch): IrKlibProtoBuf.IrCatch { - val proto = IrKlibProtoBuf.IrCatch.newBuilder() + private fun serializeCatch(catch: IrCatch): KotlinIr.IrCatch { + val proto = KotlinIr.IrCatch.newBuilder() .setCatchParameter(serializeDeclaration(catch.catchParameter)) .setResult(serializeExpression(catch.result)) return proto.build() } - private fun serializeStringConcat(expression: IrStringConcatenation): IrKlibProtoBuf.IrStringConcat { - val proto = IrKlibProtoBuf.IrStringConcat.newBuilder() + private fun serializeStringConcat(expression: IrStringConcatenation): KotlinIr.IrStringConcat { + val proto = KotlinIr.IrStringConcat.newBuilder() expression.arguments.forEach { proto.addArgument(serializeExpression(it)) } return proto.build() } - private fun irCallToPrimitiveKind(call: IrCall): IrKlibProtoBuf.IrCall.Primitive = when (call) { + private fun irCallToPrimitiveKind(call: IrCall): KotlinIr.IrCall.Primitive = when (call) { is IrNullaryPrimitiveImpl - -> IrKlibProtoBuf.IrCall.Primitive.NULLARY + -> KotlinIr.IrCall.Primitive.NULLARY is IrUnaryPrimitiveImpl - -> IrKlibProtoBuf.IrCall.Primitive.UNARY + -> KotlinIr.IrCall.Primitive.UNARY is IrBinaryPrimitiveImpl - -> IrKlibProtoBuf.IrCall.Primitive.BINARY + -> KotlinIr.IrCall.Primitive.BINARY else - -> IrKlibProtoBuf.IrCall.Primitive.NOT_PRIMITIVE + -> KotlinIr.IrCall.Primitive.NOT_PRIMITIVE } - private fun serializeMemberAccessCommon(call: IrMemberAccessExpression): IrKlibProtoBuf.MemberAccessCommon { - val proto = IrKlibProtoBuf.MemberAccessCommon.newBuilder() + private fun serializeMemberAccessCommon(call: IrMemberAccessExpression): KotlinIr.MemberAccessCommon { + val proto = KotlinIr.MemberAccessCommon.newBuilder() if (call.extensionReceiver != null) { proto.extensionReceiver = serializeExpression(call.extensionReceiver!!) } @@ -363,7 +376,7 @@ internal class IrModuleSerializer( for (index in 0..call.valueArgumentsCount - 1) { val actual = call.getValueArgument(index) - val argOrNull = IrKlibProtoBuf.NullableIrExpression.newBuilder() + val argOrNull = KotlinIr.NullableIrExpression.newBuilder() if (actual == null) { // Am I observing an IR generation regression? // I see a lack of arg for an empty vararg, @@ -379,8 +392,8 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeCall(call: IrCall): IrKlibProtoBuf.IrCall { - val proto = IrKlibProtoBuf.IrCall.newBuilder() + private fun serializeCall(call: IrCall): KotlinIr.IrCall { + val proto = KotlinIr.IrCall.newBuilder() proto.kind = irCallToPrimitiveKind(call) proto.symbol = serializeIrSymbol(call.symbol) @@ -392,8 +405,8 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeFunctionReference(callable: IrFunctionReference): IrKlibProtoBuf.IrFunctionReference { - val proto = IrKlibProtoBuf.IrFunctionReference.newBuilder() + private fun serializeFunctionReference(callable: IrFunctionReference): KotlinIr.IrFunctionReference { + val proto = KotlinIr.IrFunctionReference.newBuilder() .setSymbol(serializeIrSymbol(callable.symbol)) .setMemberAccess(serializeMemberAccessCommon(callable)) callable.origin?.let { proto.origin = serializeIrStatementOrigin(it) } @@ -401,8 +414,8 @@ internal class IrModuleSerializer( } - private fun serializePropertyReference(callable: IrPropertyReference): IrKlibProtoBuf.IrPropertyReference { - val proto = IrKlibProtoBuf.IrPropertyReference.newBuilder() + private fun serializePropertyReference(callable: IrPropertyReference): KotlinIr.IrPropertyReference { + val proto = KotlinIr.IrPropertyReference.newBuilder() .setMemberAccess(serializeMemberAccessCommon(callable)) callable.field?.let { proto.field = serializeIrSymbol(it) } callable.getter?.let { proto.getter = serializeIrSymbol(it) } @@ -413,15 +426,15 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeClassReference(expression: IrClassReference): IrKlibProtoBuf.IrClassReference { - val proto = IrKlibProtoBuf.IrClassReference.newBuilder() + private fun serializeClassReference(expression: IrClassReference): KotlinIr.IrClassReference { + val proto = KotlinIr.IrClassReference.newBuilder() .setClassSymbol(serializeIrSymbol(expression.symbol)) .setClassType(serializeIrType(expression.classType)) return proto.build() } - private fun serializeConst(value: IrConst<*>): IrKlibProtoBuf.IrConst { - val proto = IrKlibProtoBuf.IrConst.newBuilder() + private fun serializeConst(value: IrConst<*>): KotlinIr.IrConst { + val proto = KotlinIr.IrConst.newBuilder() when (value.kind) { IrConstKind.Null -> proto.`null` = true IrConstKind.Boolean -> proto.boolean = value.value as Boolean @@ -437,119 +450,119 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeDelegatingConstructorCall(call: IrDelegatingConstructorCall): IrKlibProtoBuf.IrDelegatingConstructorCall { - val proto = IrKlibProtoBuf.IrDelegatingConstructorCall.newBuilder() + private fun serializeDelegatingConstructorCall(call: IrDelegatingConstructorCall): KotlinIr.IrDelegatingConstructorCall { + val proto = KotlinIr.IrDelegatingConstructorCall.newBuilder() .setSymbol(serializeIrSymbol(call.symbol)) .setMemberAccess(serializeMemberAccessCommon(call)) return proto.build() } - private fun serializeDoWhile(expression: IrDoWhileLoop): IrKlibProtoBuf.IrDoWhile { - val proto = IrKlibProtoBuf.IrDoWhile.newBuilder() + private fun serializeDoWhile(expression: IrDoWhileLoop): KotlinIr.IrDoWhile { + val proto = KotlinIr.IrDoWhile.newBuilder() .setLoop(serializeLoop(expression)) return proto.build() } - fun serializeEnumConstructorCall(call: IrEnumConstructorCall): IrKlibProtoBuf.IrEnumConstructorCall { - val proto = IrKlibProtoBuf.IrEnumConstructorCall.newBuilder() + fun serializeEnumConstructorCall(call: IrEnumConstructorCall): KotlinIr.IrEnumConstructorCall { + val proto = KotlinIr.IrEnumConstructorCall.newBuilder() .setSymbol(serializeIrSymbol(call.symbol)) .setMemberAccess(serializeMemberAccessCommon(call)) return proto.build() } - private fun serializeGetClass(expression: IrGetClass): IrKlibProtoBuf.IrGetClass { - val proto = IrKlibProtoBuf.IrGetClass.newBuilder() + private fun serializeGetClass(expression: IrGetClass): KotlinIr.IrGetClass { + val proto = KotlinIr.IrGetClass.newBuilder() .setArgument(serializeExpression(expression.argument)) return proto.build() } - private fun serializeGetEnumValue(expression: IrGetEnumValue): IrKlibProtoBuf.IrGetEnumValue { - val proto = IrKlibProtoBuf.IrGetEnumValue.newBuilder() + private fun serializeGetEnumValue(expression: IrGetEnumValue): KotlinIr.IrGetEnumValue { + val proto = KotlinIr.IrGetEnumValue.newBuilder() .setSymbol(serializeIrSymbol(expression.symbol)) return proto.build() } - private fun serializeFieldAccessCommon(expression: IrFieldAccessExpression): IrKlibProtoBuf.FieldAccessCommon { - val proto = IrKlibProtoBuf.FieldAccessCommon.newBuilder() + private fun serializeFieldAccessCommon(expression: IrFieldAccessExpression): KotlinIr.FieldAccessCommon { + val proto = KotlinIr.FieldAccessCommon.newBuilder() .setSymbol(serializeIrSymbol(expression.symbol)) expression.superQualifierSymbol?.let { proto.`super` = serializeIrSymbol(it) } expression.receiver?.let { proto.receiver = serializeExpression(it) } return proto.build() } - private fun serializeGetField(expression: IrGetField): IrKlibProtoBuf.IrGetField { - val proto = IrKlibProtoBuf.IrGetField.newBuilder() + private fun serializeGetField(expression: IrGetField): KotlinIr.IrGetField { + val proto = KotlinIr.IrGetField.newBuilder() .setFieldAccess(serializeFieldAccessCommon(expression)) return proto.build() } - private fun serializeGetValue(expression: IrGetValue): IrKlibProtoBuf.IrGetValue { - val proto = IrKlibProtoBuf.IrGetValue.newBuilder() + private fun serializeGetValue(expression: IrGetValue): KotlinIr.IrGetValue { + val proto = KotlinIr.IrGetValue.newBuilder() .setSymbol(serializeIrSymbol(expression.symbol)) return proto.build() } - private fun serializeGetObject(expression: IrGetObjectValue): IrKlibProtoBuf.IrGetObject { - val proto = IrKlibProtoBuf.IrGetObject.newBuilder() + private fun serializeGetObject(expression: IrGetObjectValue): KotlinIr.IrGetObject { + val proto = KotlinIr.IrGetObject.newBuilder() .setSymbol(serializeIrSymbol(expression.symbol)) return proto.build() } - private fun serializeInstanceInitializerCall(call: IrInstanceInitializerCall): IrKlibProtoBuf.IrInstanceInitializerCall { - val proto = IrKlibProtoBuf.IrInstanceInitializerCall.newBuilder() + private fun serializeInstanceInitializerCall(call: IrInstanceInitializerCall): KotlinIr.IrInstanceInitializerCall { + val proto = KotlinIr.IrInstanceInitializerCall.newBuilder() proto.symbol = serializeIrSymbol(call.classSymbol) return proto.build() } - private fun serializeReturn(expression: IrReturn): IrKlibProtoBuf.IrReturn { - val proto = IrKlibProtoBuf.IrReturn.newBuilder() + private fun serializeReturn(expression: IrReturn): KotlinIr.IrReturn { + val proto = KotlinIr.IrReturn.newBuilder() .setReturnTarget(serializeIrSymbol(expression.returnTargetSymbol)) .setValue(serializeExpression(expression.value)) return proto.build() } - private fun serializeSetField(expression: IrSetField): IrKlibProtoBuf.IrSetField { - val proto = IrKlibProtoBuf.IrSetField.newBuilder() + private fun serializeSetField(expression: IrSetField): KotlinIr.IrSetField { + val proto = KotlinIr.IrSetField.newBuilder() .setFieldAccess(serializeFieldAccessCommon(expression)) .setValue(serializeExpression(expression.value)) return proto.build() } - private fun serializeSetVariable(expression: IrSetVariable): IrKlibProtoBuf.IrSetVariable { - val proto = IrKlibProtoBuf.IrSetVariable.newBuilder() + private fun serializeSetVariable(expression: IrSetVariable): KotlinIr.IrSetVariable { + val proto = KotlinIr.IrSetVariable.newBuilder() .setSymbol(serializeIrSymbol(expression.symbol)) .setValue(serializeExpression(expression.value)) return proto.build() } - private fun serializeSpreadElement(element: IrSpreadElement): IrKlibProtoBuf.IrSpreadElement { + private fun serializeSpreadElement(element: IrSpreadElement): KotlinIr.IrSpreadElement { val coordinates = serializeCoordinates(element.startOffset, element.endOffset) - return IrKlibProtoBuf.IrSpreadElement.newBuilder() + return KotlinIr.IrSpreadElement.newBuilder() .setExpression(serializeExpression(element.expression)) .setCoordinates(coordinates) .build() } - private fun serializeSyntheticBody(expression: IrSyntheticBody) = IrKlibProtoBuf.IrSyntheticBody.newBuilder() + private fun serializeSyntheticBody(expression: IrSyntheticBody) = KotlinIr.IrSyntheticBody.newBuilder() .setKind( when (expression.kind) { - IrSyntheticBodyKind.ENUM_VALUES -> IrKlibProtoBuf.IrSyntheticBodyKind.ENUM_VALUES - IrSyntheticBodyKind.ENUM_VALUEOF -> IrKlibProtoBuf.IrSyntheticBodyKind.ENUM_VALUEOF + IrSyntheticBodyKind.ENUM_VALUES -> KotlinIr.IrSyntheticBodyKind.ENUM_VALUES + IrSyntheticBodyKind.ENUM_VALUEOF -> KotlinIr.IrSyntheticBodyKind.ENUM_VALUEOF } ) .build() - private fun serializeThrow(expression: IrThrow): IrKlibProtoBuf.IrThrow { - val proto = IrKlibProtoBuf.IrThrow.newBuilder() + private fun serializeThrow(expression: IrThrow): KotlinIr.IrThrow { + val proto = KotlinIr.IrThrow.newBuilder() .setValue(serializeExpression(expression.value)) return proto.build() } - private fun serializeTry(expression: IrTry): IrKlibProtoBuf.IrTry { - val proto = IrKlibProtoBuf.IrTry.newBuilder() + private fun serializeTry(expression: IrTry): KotlinIr.IrTry { + val proto = KotlinIr.IrTry.newBuilder() .setResult(serializeExpression(expression.tryResult)) val catchList = expression.catches catchList.forEach { @@ -562,29 +575,29 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeTypeOperator(operator: IrTypeOperator): IrKlibProtoBuf.IrTypeOperator = when (operator) { + private fun serializeTypeOperator(operator: IrTypeOperator): KotlinIr.IrTypeOperator = when (operator) { IrTypeOperator.CAST - -> IrKlibProtoBuf.IrTypeOperator.CAST + -> KotlinIr.IrTypeOperator.CAST IrTypeOperator.IMPLICIT_CAST - -> IrKlibProtoBuf.IrTypeOperator.IMPLICIT_CAST + -> KotlinIr.IrTypeOperator.IMPLICIT_CAST IrTypeOperator.IMPLICIT_NOTNULL - -> IrKlibProtoBuf.IrTypeOperator.IMPLICIT_NOTNULL + -> KotlinIr.IrTypeOperator.IMPLICIT_NOTNULL IrTypeOperator.IMPLICIT_COERCION_TO_UNIT - -> IrKlibProtoBuf.IrTypeOperator.IMPLICIT_COERCION_TO_UNIT + -> KotlinIr.IrTypeOperator.IMPLICIT_COERCION_TO_UNIT IrTypeOperator.IMPLICIT_INTEGER_COERCION - -> IrKlibProtoBuf.IrTypeOperator.IMPLICIT_INTEGER_COERCION + -> KotlinIr.IrTypeOperator.IMPLICIT_INTEGER_COERCION IrTypeOperator.SAFE_CAST - -> IrKlibProtoBuf.IrTypeOperator.SAFE_CAST + -> KotlinIr.IrTypeOperator.SAFE_CAST IrTypeOperator.INSTANCEOF - -> IrKlibProtoBuf.IrTypeOperator.INSTANCEOF + -> KotlinIr.IrTypeOperator.INSTANCEOF IrTypeOperator.NOT_INSTANCEOF - -> IrKlibProtoBuf.IrTypeOperator.NOT_INSTANCEOF + -> KotlinIr.IrTypeOperator.NOT_INSTANCEOF IrTypeOperator.SAM_CONVERSION - -> IrKlibProtoBuf.IrTypeOperator.SAM_CONVERSION + -> KotlinIr.IrTypeOperator.SAM_CONVERSION } - private fun serializeTypeOp(expression: IrTypeOperatorCall): IrKlibProtoBuf.IrTypeOp { - val proto = IrKlibProtoBuf.IrTypeOp.newBuilder() + private fun serializeTypeOp(expression: IrTypeOperatorCall): KotlinIr.IrTypeOp { + val proto = KotlinIr.IrTypeOp.newBuilder() .setOperator(serializeTypeOperator(expression.operator)) .setOperand(serializeIrType(expression.typeOperand)) .setArgument(serializeExpression(expression.argument)) @@ -592,8 +605,8 @@ internal class IrModuleSerializer( } - private fun serializeVararg(expression: IrVararg): IrKlibProtoBuf.IrVararg { - val proto = IrKlibProtoBuf.IrVararg.newBuilder() + private fun serializeVararg(expression: IrVararg): KotlinIr.IrVararg { + val proto = KotlinIr.IrVararg.newBuilder() .setElementType(serializeIrType(expression.varargElementType)) expression.elements.forEach { proto.addElement(serializeVarargElement(it)) @@ -601,8 +614,8 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeVarargElement(element: IrVarargElement): IrKlibProtoBuf.IrVarargElement { - val proto = IrKlibProtoBuf.IrVarargElement.newBuilder() + private fun serializeVarargElement(element: IrVarargElement): KotlinIr.IrVarargElement { + val proto = KotlinIr.IrVarargElement.newBuilder() when (element) { is IrExpression -> proto.expression = serializeExpression(element) @@ -613,8 +626,8 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeWhen(expression: IrWhen): IrKlibProtoBuf.IrWhen { - val proto = IrKlibProtoBuf.IrWhen.newBuilder() + private fun serializeWhen(expression: IrWhen): KotlinIr.IrWhen { + val proto = KotlinIr.IrWhen.newBuilder() val branches = expression.branches branches.forEach { @@ -624,8 +637,8 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeLoop(expression: IrLoop): IrKlibProtoBuf.Loop { - val proto = IrKlibProtoBuf.Loop.newBuilder() + private fun serializeLoop(expression: IrLoop): KotlinIr.Loop { + val proto = KotlinIr.Loop.newBuilder() .setCondition(serializeExpression(expression.condition)) val label = expression.label?.let { serializeString(it) } if (label != null) { @@ -643,23 +656,23 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeWhile(expression: IrWhileLoop): IrKlibProtoBuf.IrWhile { - val proto = IrKlibProtoBuf.IrWhile.newBuilder() + private fun serializeWhile(expression: IrWhileLoop): KotlinIr.IrWhile { + val proto = KotlinIr.IrWhile.newBuilder() .setLoop(serializeLoop(expression)) return proto.build() } - private fun serializeDynamicMemberExpression(expression: IrDynamicMemberExpression): IrKlibProtoBuf.IrDynamicMemberExpression { - val proto = IrKlibProtoBuf.IrDynamicMemberExpression.newBuilder() + private fun serializeDynamicMemberExpression(expression: IrDynamicMemberExpression): KotlinIr.IrDynamicMemberExpression { + val proto = KotlinIr.IrDynamicMemberExpression.newBuilder() .setMemberName(serializeString(expression.memberName)) .setReceiver(serializeExpression(expression.receiver)) return proto.build() } - private fun serializeDynamicOperatorExpression(expression: IrDynamicOperatorExpression): IrKlibProtoBuf.IrDynamicOperatorExpression { - val proto = IrKlibProtoBuf.IrDynamicOperatorExpression.newBuilder() + private fun serializeDynamicOperatorExpression(expression: IrDynamicOperatorExpression): KotlinIr.IrDynamicOperatorExpression { + val proto = KotlinIr.IrDynamicOperatorExpression.newBuilder() .setOperator(serializeDynamicOperator(expression.operator)) .setReceiver(serializeExpression(expression.receiver)) @@ -669,51 +682,51 @@ internal class IrModuleSerializer( } private fun serializeDynamicOperator(operator: IrDynamicOperator) = when (operator) { - IrDynamicOperator.UNARY_PLUS -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS - IrDynamicOperator.UNARY_MINUS -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_MINUS + IrDynamicOperator.UNARY_PLUS -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS + IrDynamicOperator.UNARY_MINUS -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_MINUS - IrDynamicOperator.EXCL -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCL + IrDynamicOperator.EXCL -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCL - IrDynamicOperator.PREFIX_INCREMENT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_INCREMENT - IrDynamicOperator.PREFIX_DECREMENT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT + IrDynamicOperator.PREFIX_INCREMENT -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_INCREMENT + IrDynamicOperator.PREFIX_DECREMENT -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT - IrDynamicOperator.POSTFIX_INCREMENT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT - IrDynamicOperator.POSTFIX_DECREMENT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_DECREMENT + IrDynamicOperator.POSTFIX_INCREMENT -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT + IrDynamicOperator.POSTFIX_DECREMENT -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_DECREMENT - IrDynamicOperator.BINARY_PLUS -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_PLUS - IrDynamicOperator.BINARY_MINUS -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_MINUS - IrDynamicOperator.MUL -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MUL - IrDynamicOperator.DIV -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.DIV - IrDynamicOperator.MOD -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MOD + IrDynamicOperator.BINARY_PLUS -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_PLUS + IrDynamicOperator.BINARY_MINUS -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_MINUS + IrDynamicOperator.MUL -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MUL + IrDynamicOperator.DIV -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIV + IrDynamicOperator.MOD -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MOD - IrDynamicOperator.GT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.GT - IrDynamicOperator.LT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.LT - IrDynamicOperator.GE -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.GE - IrDynamicOperator.LE -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.LE + IrDynamicOperator.GT -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GT + IrDynamicOperator.LT -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LT + IrDynamicOperator.GE -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GE + IrDynamicOperator.LE -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LE - IrDynamicOperator.EQEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ - IrDynamicOperator.EXCLEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ + IrDynamicOperator.EQEQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ + IrDynamicOperator.EXCLEQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ - IrDynamicOperator.EQEQEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ - IrDynamicOperator.EXCLEQEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ + IrDynamicOperator.EQEQEQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ + IrDynamicOperator.EXCLEQEQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ - IrDynamicOperator.ANDAND -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND - IrDynamicOperator.OROR -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.OROR + IrDynamicOperator.ANDAND -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND + IrDynamicOperator.OROR -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.OROR - IrDynamicOperator.EQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQ - IrDynamicOperator.PLUSEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PLUSEQ - IrDynamicOperator.MINUSEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MINUSEQ - IrDynamicOperator.MULEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MULEQ - IrDynamicOperator.DIVEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.DIVEQ - IrDynamicOperator.MODEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MODEQ + IrDynamicOperator.EQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQ + IrDynamicOperator.PLUSEQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PLUSEQ + IrDynamicOperator.MINUSEQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MINUSEQ + IrDynamicOperator.MULEQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MULEQ + IrDynamicOperator.DIVEQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIVEQ + IrDynamicOperator.MODEQ -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MODEQ - IrDynamicOperator.ARRAY_ACCESS -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.ARRAY_ACCESS + IrDynamicOperator.ARRAY_ACCESS -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ARRAY_ACCESS - IrDynamicOperator.INVOKE -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.INVOKE + IrDynamicOperator.INVOKE -> KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.INVOKE } - private fun serializeBreak(expression: IrBreak): IrKlibProtoBuf.IrBreak { - val proto = IrKlibProtoBuf.IrBreak.newBuilder() + private fun serializeBreak(expression: IrBreak): KotlinIr.IrBreak { + val proto = KotlinIr.IrBreak.newBuilder() val label = expression.label?.let { serializeString(it) } if (label != null) { proto.label = label @@ -724,8 +737,8 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeContinue(expression: IrContinue): IrKlibProtoBuf.IrContinue { - val proto = IrKlibProtoBuf.IrContinue.newBuilder() + private fun serializeContinue(expression: IrContinue): KotlinIr.IrContinue { + val proto = KotlinIr.IrContinue.newBuilder() val label = expression.label?.let { serializeString(it) } if (label != null) { proto.label = label @@ -736,15 +749,15 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeExpression(expression: IrExpression): IrKlibProtoBuf.IrExpression { + private fun serializeExpression(expression: IrExpression): KotlinIr.IrExpression { logger.log { "### serializing Expression: ${ir2string(expression)}" } val coordinates = serializeCoordinates(expression.startOffset, expression.endOffset) - val proto = IrKlibProtoBuf.IrExpression.newBuilder() + val proto = KotlinIr.IrExpression.newBuilder() .setType(serializeIrType(expression.type)) .setCoordinates(coordinates) - val operationProto = IrKlibProtoBuf.IrOperation.newBuilder() + val operationProto = KotlinIr.IrOperation.newBuilder() // TODO: make me a visitor. when (expression) { @@ -798,11 +811,11 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeStatement(statement: IrElement): IrKlibProtoBuf.IrStatement { + private fun serializeStatement(statement: IrElement): KotlinIr.IrStatement { logger.log { "### serializing Statement: ${ir2string(statement)}" } val coordinates = serializeCoordinates(statement.startOffset, statement.endOffset) - val proto = IrKlibProtoBuf.IrStatement.newBuilder() + val proto = KotlinIr.IrStatement.newBuilder() .setCoordinates(coordinates) when (statement) { @@ -831,12 +844,12 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeIrTypeAlias(typeAlias: IrTypeAlias) = IrKlibProtoBuf.IrTypeAlias.newBuilder().build() + private fun serializeIrTypeAlias(typeAlias: IrTypeAlias) = KotlinIr.IrTypeAlias.newBuilder().build() - private fun serializeIrValueParameter(parameter: IrValueParameter): IrKlibProtoBuf.IrValueParameter { - val proto = IrKlibProtoBuf.IrValueParameter.newBuilder() + private fun serializeIrValueParameter(parameter: IrValueParameter): KotlinIr.IrValueParameter { + val proto = KotlinIr.IrValueParameter.newBuilder() .setSymbol(serializeIrSymbol(parameter.symbol)) - .setName(serializeString(parameter.name.toString())) + .setName(serializeName(parameter.name)) .setIndex(parameter.index) .setType(serializeIrType(parameter.type)) .setIsCrossinline(parameter.isCrossinline) @@ -848,10 +861,10 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeIrTypeParameter(parameter: IrTypeParameter): IrKlibProtoBuf.IrTypeParameter { - val proto = IrKlibProtoBuf.IrTypeParameter.newBuilder() + private fun serializeIrTypeParameter(parameter: IrTypeParameter): KotlinIr.IrTypeParameter { + val proto = KotlinIr.IrTypeParameter.newBuilder() .setSymbol(serializeIrSymbol(parameter.symbol)) - .setName(serializeString(parameter.name.toString())) + .setName(serializeName(parameter.name)) .setIndex(parameter.index) .setVariance(serializeIrTypeVariance(parameter.variance)) .setIsReified(parameter.isReified) @@ -861,17 +874,17 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeIrTypeParameterContainer(typeParameters: List): IrKlibProtoBuf.IrTypeParameterContainer { - val proto = IrKlibProtoBuf.IrTypeParameterContainer.newBuilder() + private fun serializeIrTypeParameterContainer(typeParameters: List): KotlinIr.IrTypeParameterContainer { + val proto = KotlinIr.IrTypeParameterContainer.newBuilder() typeParameters.forEach { proto.addTypeParameter(serializeDeclaration(it)) } return proto.build() } - private fun serializeIrFunctionBase(function: IrFunctionBase): IrKlibProtoBuf.IrFunctionBase { - val proto = IrKlibProtoBuf.IrFunctionBase.newBuilder() - .setName(serializeString(function.name.toString())) + private fun serializeIrFunctionBase(function: IrFunction): KotlinIr.IrFunctionBase { + val proto = KotlinIr.IrFunctionBase.newBuilder() + .setName(serializeName(function.name)) .setVisibility(serializeVisibility(function.visibility)) .setIsInline(function.isInline) .setIsExternal(function.isExternal) @@ -891,22 +904,22 @@ internal class IrModuleSerializer( } private fun serializeModality(modality: Modality) = when (modality) { - Modality.FINAL -> IrKlibProtoBuf.ModalityKind.FINAL_MODALITY - Modality.SEALED -> IrKlibProtoBuf.ModalityKind.SEALED_MODALITY - Modality.OPEN -> IrKlibProtoBuf.ModalityKind.OPEN_MODALITY - Modality.ABSTRACT -> IrKlibProtoBuf.ModalityKind.ABSTRACT_MODALITY + Modality.FINAL -> KotlinIr.ModalityKind.FINAL_MODALITY + Modality.SEALED -> KotlinIr.ModalityKind.SEALED_MODALITY + Modality.OPEN -> KotlinIr.ModalityKind.OPEN_MODALITY + Modality.ABSTRACT -> KotlinIr.ModalityKind.ABSTRACT_MODALITY } - private fun serializeIrConstructor(declaration: IrConstructor): IrKlibProtoBuf.IrConstructor = - IrKlibProtoBuf.IrConstructor.newBuilder() + private fun serializeIrConstructor(declaration: IrConstructor): KotlinIr.IrConstructor = + KotlinIr.IrConstructor.newBuilder() .setSymbol(serializeIrSymbol(declaration.symbol)) - .setBase(serializeIrFunctionBase(declaration as IrFunctionBase)) + .setBase(serializeIrFunctionBase(declaration)) .setIsPrimary(declaration.isPrimary) .build() - private fun serializeIrFunction(declaration: IrSimpleFunction): IrKlibProtoBuf.IrFunction { + private fun serializeIrFunction(declaration: IrSimpleFunction): KotlinIr.IrFunction { val function = declaration// as IrFunctionImpl - val proto = IrKlibProtoBuf.IrFunction.newBuilder() + val proto = KotlinIr.IrFunction.newBuilder() .setSymbol(serializeIrSymbol(function.symbol)) .setModality(serializeModality(function.modality)) .setIsTailrec(function.isTailrec) @@ -921,23 +934,23 @@ internal class IrModuleSerializer( // proto.setCorrespondingProperty(protoUniqId(uniqId)) //} - val base = serializeIrFunctionBase(function as IrFunctionBase) + val base = serializeIrFunctionBase(function) proto.setBase(base) return proto.build() } - private fun serializeIrAnonymousInit(declaration: IrAnonymousInitializer) = IrKlibProtoBuf.IrAnonymousInit.newBuilder() + private fun serializeIrAnonymousInit(declaration: IrAnonymousInitializer) = KotlinIr.IrAnonymousInit.newBuilder() .setSymbol(serializeIrSymbol(declaration.symbol)) .setBody(serializeStatement(declaration.body)) .build() - private fun serializeIrProperty(property: IrProperty): IrKlibProtoBuf.IrProperty { + private fun serializeIrProperty(property: IrProperty): KotlinIr.IrProperty { val index = declarationTable.uniqIdByDeclaration(property) - val proto = IrKlibProtoBuf.IrProperty.newBuilder() + val proto = KotlinIr.IrProperty.newBuilder() .setIsDelegated(property.isDelegated) - .setName(serializeString(property.name.toString())) + .setName(serializeName(property.name)) .setVisibility(serializeVisibility(property.visibility)) .setModality(serializeModality(property.modality)) .setIsVar(property.isVar) @@ -961,10 +974,10 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeIrField(field: IrField): IrKlibProtoBuf.IrField { - val proto = IrKlibProtoBuf.IrField.newBuilder() + private fun serializeIrField(field: IrField): KotlinIr.IrField { + val proto = KotlinIr.IrField.newBuilder() .setSymbol(serializeIrSymbol(field.symbol)) - .setName(serializeString(field.name.toString())) + .setName(serializeName(field.name)) .setVisibility(serializeVisibility(field.visibility)) .setIsFinal(field.isFinal) .setIsExternal(field.isExternal) @@ -977,10 +990,10 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeIrVariable(variable: IrVariable): IrKlibProtoBuf.IrVariable { - val proto = IrKlibProtoBuf.IrVariable.newBuilder() + private fun serializeIrVariable(variable: IrVariable): KotlinIr.IrVariable { + val proto = KotlinIr.IrVariable.newBuilder() .setSymbol(serializeIrSymbol(variable.symbol)) - .setName(serializeString(variable.name.toString())) + .setName(serializeName(variable.name)) .setType(serializeIrType(variable.type)) .setIsConst(variable.isConst) .setIsVar(variable.isVar) @@ -989,8 +1002,8 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeIrDeclarationContainer(declarations: List): IrKlibProtoBuf.IrDeclarationContainer { - val proto = IrKlibProtoBuf.IrDeclarationContainer.newBuilder() + private fun serializeIrDeclarationContainer(declarations: List): KotlinIr.IrDeclarationContainer { + val proto = KotlinIr.IrDeclarationContainer.newBuilder() declarations.forEach { //if (it is IrDeclarationWithVisibility && it.visibility == Visibilities.INVISIBLE_FAKE) return@forEach proto.addDeclaration(serializeDeclaration(it)) @@ -999,17 +1012,17 @@ internal class IrModuleSerializer( } private fun serializeClassKind(kind: ClassKind) = when (kind) { - CLASS -> IrKlibProtoBuf.ClassKind.CLASS - INTERFACE -> IrKlibProtoBuf.ClassKind.INTERFACE - ENUM_CLASS -> IrKlibProtoBuf.ClassKind.ENUM_CLASS - ENUM_ENTRY -> IrKlibProtoBuf.ClassKind.ENUM_ENTRY - ANNOTATION_CLASS -> IrKlibProtoBuf.ClassKind.ANNOTATION_CLASS - OBJECT -> IrKlibProtoBuf.ClassKind.OBJECT + CLASS -> KotlinIr.ClassKind.CLASS + INTERFACE -> KotlinIr.ClassKind.INTERFACE + ENUM_CLASS -> KotlinIr.ClassKind.ENUM_CLASS + ENUM_ENTRY -> KotlinIr.ClassKind.ENUM_ENTRY + ANNOTATION_CLASS -> KotlinIr.ClassKind.ANNOTATION_CLASS + OBJECT -> KotlinIr.ClassKind.OBJECT } - private fun serializeIrClass(clazz: IrClass): IrKlibProtoBuf.IrClass { - val proto = IrKlibProtoBuf.IrClass.newBuilder() - .setName(serializeString(clazz.name.toString())) + private fun serializeIrClass(clazz: IrClass): KotlinIr.IrClass { + val proto = KotlinIr.IrClass.newBuilder() + .setName(serializeName(clazz.name)) .setSymbol(serializeIrSymbol(clazz.symbol)) .setKind(serializeClassKind(clazz.kind)) .setVisibility(serializeVisibility(clazz.visibility)) @@ -1029,9 +1042,9 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeIrEnumEntry(enumEntry: IrEnumEntry): IrKlibProtoBuf.IrEnumEntry { - val proto = IrKlibProtoBuf.IrEnumEntry.newBuilder() - .setName(serializeString(enumEntry.name.toString())) + private fun serializeIrEnumEntry(enumEntry: IrEnumEntry): KotlinIr.IrEnumEntry { + val proto = KotlinIr.IrEnumEntry.newBuilder() + .setName(serializeName(enumEntry.name)) .setSymbol(serializeIrSymbol(enumEntry.symbol)) enumEntry.initializerExpression?.let { @@ -1043,10 +1056,10 @@ internal class IrModuleSerializer( return proto.build() } - private fun serializeDeclaration(declaration: IrDeclaration): IrKlibProtoBuf.IrDeclaration { + private fun serializeDeclaration(declaration: IrDeclaration): KotlinIr.IrDeclaration { logger.log { "### serializing Declaration: ${ir2string(declaration)}" } - val declarator = IrKlibProtoBuf.IrDeclarator.newBuilder() + val declarator = KotlinIr.IrDeclarator.newBuilder() when (declaration) { is IrTypeAlias @@ -1078,7 +1091,7 @@ internal class IrModuleSerializer( val coordinates = serializeCoordinates(declaration.startOffset, declaration.endOffset) val annotations = serializeAnnotations(declaration.annotations) val origin = serializeIrDeclarationOrigin(declaration.origin) - val proto = IrKlibProtoBuf.IrDeclaration.newBuilder() + val proto = KotlinIr.IrDeclaration.newBuilder() .setCoordinates(coordinates) .setAnnotations(annotations) .setOrigin(origin) @@ -1091,48 +1104,87 @@ internal class IrModuleSerializer( // ---------- Top level ------------------------------------------------------ - fun serializeFileEntry(entry: SourceManager.FileEntry) = IrKlibProtoBuf.FileEntry.newBuilder() + fun serializeFileEntry(entry: SourceManager.FileEntry) = KotlinIr.FileEntry.newBuilder() .setName(serializeString(entry.name)) .addAllLineStartOffsets(entry.lineStartOffsets.asIterable()) .build() - val topLevelDeclarations = mutableMapOf() + open fun backendSpecificExplicitRoot(declaration: IrFunction) = false + open fun backendSpecificExplicitRoot(declaration: IrClass) = false - fun serializeIrFile(file: IrFile): IrKlibProtoBuf.IrFile { - val proto = IrKlibProtoBuf.IrFile.newBuilder() + fun serializeIrFile(file: IrFile): KotlinIr.IrFile { + val proto = KotlinIr.IrFile.newBuilder() .setFileEntry(serializeFileEntry(file.fileEntry)) .setFqName(serializeString(file.fqName.toString())) + .setAnnotations(serializeAnnotations(file.annotations)) file.declarations.forEach { - if (it is IrTypeAlias) return@forEach - if (it.descriptor.isExpectMember && !it.descriptor.isSerializableExpectClass) { + if (it is IrTypeAlias || (it.descriptor.isExpectMember && !it.descriptor.isSerializableExpectClass)) { + writer.skipDeclaration() return@forEach } val byteArray = serializeDeclaration(it).toByteArray() val uniqId = declarationTable.uniqIdByDeclaration(it) - topLevelDeclarations.put(uniqId, byteArray) + writer.addDeclaration(DeclarationId(uniqId.index, uniqId.isLocal), byteArray) proto.addDeclarationId(protoUniqId(uniqId)) } + + // TODO: is it Konan specific? + + // Make sure that all top level properties are initialized on library's load. + file.declarations + .filterIsInstance() + .filter { it.backingField?.initializer != null && !it.isConst } + .forEach { proto.addExplicitlyExportedToCompiler(serializeIrSymbol(it.backingField!!.symbol)) } + + // TODO: Konan specific + + file.acceptVoid(object: IrElementVisitorVoid { + override fun visitElement(element: IrElement) { + element.acceptChildrenVoid(this) + } + + override fun visitFunction(declaration: IrFunction) { + if (backendSpecificExplicitRoot(declaration)) { + proto.addExplicitlyExportedToCompiler(serializeIrSymbol(declaration.symbol)) + } + super.visitDeclaration(declaration) + } + + override fun visitClass(declaration: IrClass) { + if (backendSpecificExplicitRoot(declaration)) { + proto.addExplicitlyExportedToCompiler(serializeIrSymbol(declaration.symbol)) + } + super.visitDeclaration(declaration) + } + }) + return proto.build() } - fun serializeModule(module: IrModuleFragment): IrKlibProtoBuf.IrModule { - val proto = IrKlibProtoBuf.IrModule.newBuilder() - .setName(serializeString(module.name.toString())) + lateinit var writer: CombinedIrFileWriter + + fun serializeModule(module: IrModuleFragment): KotlinIr.IrModule { + val proto = KotlinIr.IrModule.newBuilder() + .setName(serializeName(module.name)) + + val topLevelDeclarationsCount = module.files.sumBy { it.declarations.size } + + writer = CombinedIrFileWriter(topLevelDeclarationsCount) module.files.forEach { proto.addFile(serializeIrFile(it)) } - proto.symbolTable = IrKlibProtoBuf.IrSymbolTable.newBuilder() + proto.symbolTable = KotlinIr.IrSymbolTable.newBuilder() .addAllSymbols(protoSymbolArray) .build() - proto.typeTable = IrKlibProtoBuf.IrTypeTable.newBuilder() + proto.typeTable = KotlinIr.IrTypeTable.newBuilder() .addAllTypes(protoTypeArray) .build() - proto.stringTable = IrKlibProtoBuf.StringTable.newBuilder() + proto.stringTable = KotlinIr.StringTable.newBuilder() .addAllStrings(protoStringArray) .build() @@ -1141,6 +1193,6 @@ internal class IrModuleSerializer( fun serializedIrModule(module: IrModuleFragment): SerializedIr { val moduleHeader = serializeModule(module).toByteArray() - return SerializedIr(moduleHeader, topLevelDeclarations, declarationTable.debugIndex) + return SerializedIr(moduleHeader, writer.finishWriting().absolutePath) } } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KLibraryUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KlibWriter.kt similarity index 58% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KLibraryUtils.kt rename to compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KlibWriter.kt index a8bfad0ad38..b3a36b21f6b 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KLibraryUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KlibWriter.kt @@ -3,10 +3,9 @@ * that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +package org.jetbrains.kotlin.backend.common.serialization class SerializedIr ( val module: ByteArray, - val declarations: Map, - val debugIndex: Map -) \ No newline at end of file + val combinedDeclarationFilePath: String +) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.java b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.java new file mode 100644 index 00000000000..a3911d32f26 --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.java @@ -0,0 +1,61319 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: compiler/ir/backend.common/src/KotlinIr.proto + +package org.jetbrains.kotlin.backend.common.serialization; + +public final class KotlinIr { + private KotlinIr() {} + public static void registerAllExtensions( + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite registry) { + } + /** + * Protobuf enum {@code org.jetbrains.kotlin.backend.common.serialization.KnownOrigin} + */ + public enum KnownOrigin + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * CUSTOM = 1; + */ + CUSTOM(0, 1), + /** + * DEFINED = 2; + */ + DEFINED(1, 2), + /** + * FAKE_OVERRIDE = 3; + */ + FAKE_OVERRIDE(2, 3), + /** + * FOR_LOOP_ITERATOR = 4; + */ + FOR_LOOP_ITERATOR(3, 4), + /** + * FOR_LOOP_VARIABLE = 5; + */ + FOR_LOOP_VARIABLE(4, 5), + /** + * FOR_LOOP_IMPLICIT_VARIABLE = 6; + */ + FOR_LOOP_IMPLICIT_VARIABLE(5, 6), + /** + * PROPERTY_BACKING_FIELD = 7; + */ + PROPERTY_BACKING_FIELD(6, 7), + /** + * DEFAULT_PROPERTY_ACCESSOR = 8; + */ + DEFAULT_PROPERTY_ACCESSOR(7, 8), + /** + * DELEGATE = 9; + */ + DELEGATE(8, 9), + /** + * DELEGATED_PROPERTY_ACCESSOR = 10; + */ + DELEGATED_PROPERTY_ACCESSOR(9, 10), + /** + * DELEGATED_MEMBER = 11; + */ + DELEGATED_MEMBER(10, 11), + /** + * ENUM_CLASS_SPECIAL_MEMBER = 12; + */ + ENUM_CLASS_SPECIAL_MEMBER(11, 12), + /** + * FUNCTION_FOR_DEFAULT_PARAMETER = 13; + */ + FUNCTION_FOR_DEFAULT_PARAMETER(12, 13), + /** + * FILE_CLASS = 14; + */ + FILE_CLASS(13, 14), + /** + * GENERATED_DATA_CLASS_MEMBER = 15; + */ + GENERATED_DATA_CLASS_MEMBER(14, 15), + /** + * GENERATED_INLINE_CLASS_MEMBER = 16; + */ + GENERATED_INLINE_CLASS_MEMBER(15, 16), + /** + * LOCAL_FUNCTION_FOR_LAMBDA = 17; + */ + LOCAL_FUNCTION_FOR_LAMBDA(16, 17), + /** + * CATCH_PARAMETER = 19; + */ + CATCH_PARAMETER(17, 19), + /** + * INSTANCE_RECEIVER = 20; + */ + INSTANCE_RECEIVER(18, 20), + /** + * PRIMARY_CONSTRUCTOR_PARAMETER = 21; + */ + PRIMARY_CONSTRUCTOR_PARAMETER(19, 21), + /** + * IR_TEMPORARY_VARIABLE = 22; + */ + IR_TEMPORARY_VARIABLE(20, 22), + /** + * IR_EXTERNAL_DECLARATION_STUB = 23; + */ + IR_EXTERNAL_DECLARATION_STUB(21, 23), + /** + * IR_EXTERNAL_JAVA_DECLARATION_STUB = 24; + */ + IR_EXTERNAL_JAVA_DECLARATION_STUB(22, 24), + /** + * IR_BUILTINS_STUB = 25; + */ + IR_BUILTINS_STUB(23, 25), + /** + * BRIDGE = 26; + */ + BRIDGE(24, 26), + /** + * FIELD_FOR_ENUM_ENTRY = 27; + */ + FIELD_FOR_ENUM_ENTRY(25, 27), + /** + * FIELD_FOR_ENUM_VALUES = 28; + */ + FIELD_FOR_ENUM_VALUES(26, 28), + /** + * FIELD_FOR_OBJECT_INSTANCE = 29; + */ + FIELD_FOR_OBJECT_INSTANCE(27, 29), + ; + + /** + * CUSTOM = 1; + */ + public static final int CUSTOM_VALUE = 1; + /** + * DEFINED = 2; + */ + public static final int DEFINED_VALUE = 2; + /** + * FAKE_OVERRIDE = 3; + */ + public static final int FAKE_OVERRIDE_VALUE = 3; + /** + * FOR_LOOP_ITERATOR = 4; + */ + public static final int FOR_LOOP_ITERATOR_VALUE = 4; + /** + * FOR_LOOP_VARIABLE = 5; + */ + public static final int FOR_LOOP_VARIABLE_VALUE = 5; + /** + * FOR_LOOP_IMPLICIT_VARIABLE = 6; + */ + public static final int FOR_LOOP_IMPLICIT_VARIABLE_VALUE = 6; + /** + * PROPERTY_BACKING_FIELD = 7; + */ + public static final int PROPERTY_BACKING_FIELD_VALUE = 7; + /** + * DEFAULT_PROPERTY_ACCESSOR = 8; + */ + public static final int DEFAULT_PROPERTY_ACCESSOR_VALUE = 8; + /** + * DELEGATE = 9; + */ + public static final int DELEGATE_VALUE = 9; + /** + * DELEGATED_PROPERTY_ACCESSOR = 10; + */ + public static final int DELEGATED_PROPERTY_ACCESSOR_VALUE = 10; + /** + * DELEGATED_MEMBER = 11; + */ + public static final int DELEGATED_MEMBER_VALUE = 11; + /** + * ENUM_CLASS_SPECIAL_MEMBER = 12; + */ + public static final int ENUM_CLASS_SPECIAL_MEMBER_VALUE = 12; + /** + * FUNCTION_FOR_DEFAULT_PARAMETER = 13; + */ + public static final int FUNCTION_FOR_DEFAULT_PARAMETER_VALUE = 13; + /** + * FILE_CLASS = 14; + */ + public static final int FILE_CLASS_VALUE = 14; + /** + * GENERATED_DATA_CLASS_MEMBER = 15; + */ + public static final int GENERATED_DATA_CLASS_MEMBER_VALUE = 15; + /** + * GENERATED_INLINE_CLASS_MEMBER = 16; + */ + public static final int GENERATED_INLINE_CLASS_MEMBER_VALUE = 16; + /** + * LOCAL_FUNCTION_FOR_LAMBDA = 17; + */ + public static final int LOCAL_FUNCTION_FOR_LAMBDA_VALUE = 17; + /** + * CATCH_PARAMETER = 19; + */ + public static final int CATCH_PARAMETER_VALUE = 19; + /** + * INSTANCE_RECEIVER = 20; + */ + public static final int INSTANCE_RECEIVER_VALUE = 20; + /** + * PRIMARY_CONSTRUCTOR_PARAMETER = 21; + */ + public static final int PRIMARY_CONSTRUCTOR_PARAMETER_VALUE = 21; + /** + * IR_TEMPORARY_VARIABLE = 22; + */ + public static final int IR_TEMPORARY_VARIABLE_VALUE = 22; + /** + * IR_EXTERNAL_DECLARATION_STUB = 23; + */ + public static final int IR_EXTERNAL_DECLARATION_STUB_VALUE = 23; + /** + * IR_EXTERNAL_JAVA_DECLARATION_STUB = 24; + */ + public static final int IR_EXTERNAL_JAVA_DECLARATION_STUB_VALUE = 24; + /** + * IR_BUILTINS_STUB = 25; + */ + public static final int IR_BUILTINS_STUB_VALUE = 25; + /** + * BRIDGE = 26; + */ + public static final int BRIDGE_VALUE = 26; + /** + * FIELD_FOR_ENUM_ENTRY = 27; + */ + public static final int FIELD_FOR_ENUM_ENTRY_VALUE = 27; + /** + * FIELD_FOR_ENUM_VALUES = 28; + */ + public static final int FIELD_FOR_ENUM_VALUES_VALUE = 28; + /** + * FIELD_FOR_OBJECT_INSTANCE = 29; + */ + public static final int FIELD_FOR_OBJECT_INSTANCE_VALUE = 29; + + + public final int getNumber() { return value; } + + public static KnownOrigin valueOf(int value) { + switch (value) { + case 1: return CUSTOM; + case 2: return DEFINED; + case 3: return FAKE_OVERRIDE; + case 4: return FOR_LOOP_ITERATOR; + case 5: return FOR_LOOP_VARIABLE; + case 6: return FOR_LOOP_IMPLICIT_VARIABLE; + case 7: return PROPERTY_BACKING_FIELD; + case 8: return DEFAULT_PROPERTY_ACCESSOR; + case 9: return DELEGATE; + case 10: return DELEGATED_PROPERTY_ACCESSOR; + case 11: return DELEGATED_MEMBER; + case 12: return ENUM_CLASS_SPECIAL_MEMBER; + case 13: return FUNCTION_FOR_DEFAULT_PARAMETER; + case 14: return FILE_CLASS; + case 15: return GENERATED_DATA_CLASS_MEMBER; + case 16: return GENERATED_INLINE_CLASS_MEMBER; + case 17: return LOCAL_FUNCTION_FOR_LAMBDA; + case 19: return CATCH_PARAMETER; + case 20: return INSTANCE_RECEIVER; + case 21: return PRIMARY_CONSTRUCTOR_PARAMETER; + case 22: return IR_TEMPORARY_VARIABLE; + case 23: return IR_EXTERNAL_DECLARATION_STUB; + case 24: return IR_EXTERNAL_JAVA_DECLARATION_STUB; + case 25: return IR_BUILTINS_STUB; + case 26: return BRIDGE; + case 27: return FIELD_FOR_ENUM_ENTRY; + case 28: return FIELD_FOR_ENUM_VALUES; + case 29: return FIELD_FOR_OBJECT_INSTANCE; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public KnownOrigin findValueByNumber(int number) { + return KnownOrigin.valueOf(number); + } + }; + + private final int value; + + private KnownOrigin(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.backend.common.serialization.KnownOrigin) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind} + */ + public enum IrSymbolKind + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * FUNCTION_SYMBOL = 1; + */ + FUNCTION_SYMBOL(0, 1), + /** + * CONSTRUCTOR_SYMBOL = 2; + */ + CONSTRUCTOR_SYMBOL(1, 2), + /** + * ENUM_ENTRY_SYMBOL = 3; + */ + ENUM_ENTRY_SYMBOL(2, 3), + /** + * FIELD_SYMBOL = 4; + */ + FIELD_SYMBOL(3, 4), + /** + * VALUE_PARAMETER_SYMBOL = 5; + */ + VALUE_PARAMETER_SYMBOL(4, 5), + /** + * RETURNABLE_BLOCK_SYMBOL = 6; + */ + RETURNABLE_BLOCK_SYMBOL(5, 6), + /** + * CLASS_SYMBOL = 7; + */ + CLASS_SYMBOL(6, 7), + /** + * TYPE_PARAMETER_SYMBOL = 8; + */ + TYPE_PARAMETER_SYMBOL(7, 8), + /** + * VARIABLE_SYMBOL = 9; + */ + VARIABLE_SYMBOL(8, 9), + /** + * ANONYMOUS_INIT_SYMBOL = 10; + */ + ANONYMOUS_INIT_SYMBOL(9, 10), + /** + * STANDALONE_FIELD_SYMBOL = 11; + * + * 
+     * For fields without properties. WrappedFieldDescriptor, rather than WrappedPropertyDescriptor.
+     *
+ */ + STANDALONE_FIELD_SYMBOL(10, 11), + /** + * RECEIVER_PARAMETER_SYMBOL = 12; + * + * 
+     * ReceiverParameterDescriptor rather than ValueParameterDescriptor.
+     *
+ */ + RECEIVER_PARAMETER_SYMBOL(11, 12), + ; + + /** + * FUNCTION_SYMBOL = 1; + */ + public static final int FUNCTION_SYMBOL_VALUE = 1; + /** + * CONSTRUCTOR_SYMBOL = 2; + */ + public static final int CONSTRUCTOR_SYMBOL_VALUE = 2; + /** + * ENUM_ENTRY_SYMBOL = 3; + */ + public static final int ENUM_ENTRY_SYMBOL_VALUE = 3; + /** + * FIELD_SYMBOL = 4; + */ + public static final int FIELD_SYMBOL_VALUE = 4; + /** + * VALUE_PARAMETER_SYMBOL = 5; + */ + public static final int VALUE_PARAMETER_SYMBOL_VALUE = 5; + /** + * RETURNABLE_BLOCK_SYMBOL = 6; + */ + public static final int RETURNABLE_BLOCK_SYMBOL_VALUE = 6; + /** + * CLASS_SYMBOL = 7; + */ + public static final int CLASS_SYMBOL_VALUE = 7; + /** + * TYPE_PARAMETER_SYMBOL = 8; + */ + public static final int TYPE_PARAMETER_SYMBOL_VALUE = 8; + /** + * VARIABLE_SYMBOL = 9; + */ + public static final int VARIABLE_SYMBOL_VALUE = 9; + /** + * ANONYMOUS_INIT_SYMBOL = 10; + */ + public static final int ANONYMOUS_INIT_SYMBOL_VALUE = 10; + /** + * STANDALONE_FIELD_SYMBOL = 11; + * + * 
+     * For fields without properties. WrappedFieldDescriptor, rather than WrappedPropertyDescriptor.
+     *
+ */ + public static final int STANDALONE_FIELD_SYMBOL_VALUE = 11; + /** + * RECEIVER_PARAMETER_SYMBOL = 12; + * + * 
+     * ReceiverParameterDescriptor rather than ValueParameterDescriptor.
+     *
+ */ + public static final int RECEIVER_PARAMETER_SYMBOL_VALUE = 12; + + + public final int getNumber() { return value; } + + public static IrSymbolKind valueOf(int value) { + switch (value) { + case 1: return FUNCTION_SYMBOL; + case 2: return CONSTRUCTOR_SYMBOL; + case 3: return ENUM_ENTRY_SYMBOL; + case 4: return FIELD_SYMBOL; + case 5: return VALUE_PARAMETER_SYMBOL; + case 6: return RETURNABLE_BLOCK_SYMBOL; + case 7: return CLASS_SYMBOL; + case 8: return TYPE_PARAMETER_SYMBOL; + case 9: return VARIABLE_SYMBOL; + case 10: return ANONYMOUS_INIT_SYMBOL; + case 11: return STANDALONE_FIELD_SYMBOL; + case 12: return RECEIVER_PARAMETER_SYMBOL; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public IrSymbolKind findValueByNumber(int number) { + return IrSymbolKind.valueOf(number); + } + }; + + private final int value; + + private IrSymbolKind(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance} + * + * 
+   * Should we import metadata variance, or better stay separate?
+   *
+ */ + public enum IrTypeVariance + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * IN = 0; + */ + IN(0, 0), + /** + * OUT = 1; + */ + OUT(1, 1), + /** + * INV = 2; + */ + INV(2, 2), + ; + + /** + * IN = 0; + */ + public static final int IN_VALUE = 0; + /** + * OUT = 1; + */ + public static final int OUT_VALUE = 1; + /** + * INV = 2; + */ + public static final int INV_VALUE = 2; + + + public final int getNumber() { return value; } + + public static IrTypeVariance valueOf(int value) { + switch (value) { + case 0: return IN; + case 1: return OUT; + case 2: return INV; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public IrTypeVariance findValueByNumber(int number) { + return IrTypeVariance.valueOf(number); + } + }; + + private final int value; + + private IrTypeVariance(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator} + */ + public enum IrTypeOperator + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * CAST = 1; + */ + CAST(0, 1), + /** + * IMPLICIT_CAST = 2; + */ + IMPLICIT_CAST(1, 2), + /** + * IMPLICIT_NOTNULL = 3; + */ + IMPLICIT_NOTNULL(2, 3), + /** + * IMPLICIT_COERCION_TO_UNIT = 4; + */ + IMPLICIT_COERCION_TO_UNIT(3, 4), + /** + * IMPLICIT_INTEGER_COERCION = 5; + */ + IMPLICIT_INTEGER_COERCION(4, 5), + /** + * SAFE_CAST = 6; + */ + SAFE_CAST(5, 6), + /** + * INSTANCEOF = 7; + */ + INSTANCEOF(6, 7), + /** + * NOT_INSTANCEOF = 8; + */ + NOT_INSTANCEOF(7, 8), + /** + * SAM_CONVERSION = 9; + */ + SAM_CONVERSION(8, 9), + ; + + /** + * CAST = 1; + */ + public static final int CAST_VALUE = 1; + /** + * IMPLICIT_CAST = 2; + */ + public static final int IMPLICIT_CAST_VALUE = 2; + /** + * IMPLICIT_NOTNULL = 3; + */ + public static final int IMPLICIT_NOTNULL_VALUE = 3; + /** + * IMPLICIT_COERCION_TO_UNIT = 4; + */ + public static final int IMPLICIT_COERCION_TO_UNIT_VALUE = 4; + /** + * IMPLICIT_INTEGER_COERCION = 5; + */ + public static final int IMPLICIT_INTEGER_COERCION_VALUE = 5; + /** + * SAFE_CAST = 6; + */ + public static final int SAFE_CAST_VALUE = 6; + /** + * INSTANCEOF = 7; + */ + public static final int INSTANCEOF_VALUE = 7; + /** + * NOT_INSTANCEOF = 8; + */ + public static final int NOT_INSTANCEOF_VALUE = 8; + /** + * SAM_CONVERSION = 9; + */ + public static final int SAM_CONVERSION_VALUE = 9; + + + public final int getNumber() { return value; } + + public static IrTypeOperator valueOf(int value) { + switch (value) { + case 1: return CAST; + case 2: return IMPLICIT_CAST; + case 3: return IMPLICIT_NOTNULL; + case 4: return IMPLICIT_COERCION_TO_UNIT; + case 5: return IMPLICIT_INTEGER_COERCION; + case 6: return SAFE_CAST; + case 7: return INSTANCEOF; + case 8: return NOT_INSTANCEOF; + case 9: return SAM_CONVERSION; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public IrTypeOperator findValueByNumber(int number) { + return IrTypeOperator.valueOf(number); + } + }; + + private final int value; + + private IrTypeOperator(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.backend.common.serialization.ClassKind} + */ + public enum ClassKind + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * CLASS = 1; + */ + CLASS(0, 1), + /** + * INTERFACE = 2; + */ + INTERFACE(1, 2), + /** + * ENUM_CLASS = 3; + */ + ENUM_CLASS(2, 3), + /** + * ENUM_ENTRY = 4; + */ + ENUM_ENTRY(3, 4), + /** + * ANNOTATION_CLASS = 5; + */ + ANNOTATION_CLASS(4, 5), + /** + * OBJECT = 6; + */ + OBJECT(5, 6), + ; + + /** + * CLASS = 1; + */ + public static final int CLASS_VALUE = 1; + /** + * INTERFACE = 2; + */ + public static final int INTERFACE_VALUE = 2; + /** + * ENUM_CLASS = 3; + */ + public static final int ENUM_CLASS_VALUE = 3; + /** + * ENUM_ENTRY = 4; + */ + public static final int ENUM_ENTRY_VALUE = 4; + /** + * ANNOTATION_CLASS = 5; + */ + public static final int ANNOTATION_CLASS_VALUE = 5; + /** + * OBJECT = 6; + */ + public static final int OBJECT_VALUE = 6; + + + public final int getNumber() { return value; } + + public static ClassKind valueOf(int value) { + switch (value) { + case 1: return CLASS; + case 2: return INTERFACE; + case 3: return ENUM_CLASS; + case 4: return ENUM_ENTRY; + case 5: return ANNOTATION_CLASS; + case 6: return OBJECT; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public ClassKind findValueByNumber(int number) { + return ClassKind.valueOf(number); + } + }; + + private final int value; + + private ClassKind(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.backend.common.serialization.ClassKind) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.backend.common.serialization.ModalityKind} + * + * 
+   * It is ModalityKind to not clash with Modality in descriptor metadata.
+   *
+ */ + public enum ModalityKind + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * FINAL_MODALITY = 1; + */ + FINAL_MODALITY(0, 1), + /** + * SEALED_MODALITY = 2; + */ + SEALED_MODALITY(1, 2), + /** + * OPEN_MODALITY = 3; + */ + OPEN_MODALITY(2, 3), + /** + * ABSTRACT_MODALITY = 4; + */ + ABSTRACT_MODALITY(3, 4), + ; + + /** + * FINAL_MODALITY = 1; + */ + public static final int FINAL_MODALITY_VALUE = 1; + /** + * SEALED_MODALITY = 2; + */ + public static final int SEALED_MODALITY_VALUE = 2; + /** + * OPEN_MODALITY = 3; + */ + public static final int OPEN_MODALITY_VALUE = 3; + /** + * ABSTRACT_MODALITY = 4; + */ + public static final int ABSTRACT_MODALITY_VALUE = 4; + + + public final int getNumber() { return value; } + + public static ModalityKind valueOf(int value) { + switch (value) { + case 1: return FINAL_MODALITY; + case 2: return SEALED_MODALITY; + case 3: return OPEN_MODALITY; + case 4: return ABSTRACT_MODALITY; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public ModalityKind findValueByNumber(int number) { + return ModalityKind.valueOf(number); + } + }; + + private final int value; + + private ModalityKind(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.backend.common.serialization.ModalityKind) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind} + */ + public enum IrSyntheticBodyKind + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * ENUM_VALUES = 1; + */ + ENUM_VALUES(0, 1), + /** + * ENUM_VALUEOF = 2; + */ + ENUM_VALUEOF(1, 2), + ; + + /** + * ENUM_VALUES = 1; + */ + public static final int ENUM_VALUES_VALUE = 1; + /** + * ENUM_VALUEOF = 2; + */ + public static final int ENUM_VALUEOF_VALUE = 2; + + + public final int getNumber() { return value; } + + public static IrSyntheticBodyKind valueOf(int value) { + switch (value) { + case 1: return ENUM_VALUES; + case 2: return ENUM_VALUEOF; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public IrSyntheticBodyKind findValueByNumber(int number) { + return IrSyntheticBodyKind.valueOf(number); + } + }; + + private final int value; + + private IrSyntheticBodyKind(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind) + } + + public interface DescriptorReferenceOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.DescriptorReference) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + boolean hasPackageFqName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getPackageFqName(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + boolean hasClassFqName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getClassFqName(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + boolean hasUniqId(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getUniqId(); + + /** + * optional bool is_getter = 5 [default = false]; + */ + boolean hasIsGetter(); + /** + * optional bool is_getter = 5 [default = false]; + */ + boolean getIsGetter(); + + /** + * optional bool is_setter = 6 [default = false]; + */ + boolean hasIsSetter(); + /** + * optional bool is_setter = 6 [default = false]; + */ + boolean getIsSetter(); + + /** + * optional bool is_backing_field = 7 [default = false]; + */ + boolean hasIsBackingField(); + /** + * optional bool is_backing_field = 7 [default = false]; + */ + boolean getIsBackingField(); + + /** + * optional bool is_fake_override = 8 [default = false]; + */ + boolean hasIsFakeOverride(); + /** + * optional bool is_fake_override = 8 [default = false]; + */ + boolean getIsFakeOverride(); + + /** + * optional bool is_default_constructor = 9 [default = false]; + */ + boolean hasIsDefaultConstructor(); + /** + * optional bool is_default_constructor = 9 [default = false]; + */ + boolean getIsDefaultConstructor(); + + /** + * optional bool is_enum_entry = 10 [default = false]; + */ + boolean hasIsEnumEntry(); + /** + * optional bool is_enum_entry = 10 [default = false]; + */ + boolean getIsEnumEntry(); + + /** + * optional bool is_enum_special = 11 [default = false]; + */ + boolean hasIsEnumSpecial(); + /** + * optional bool is_enum_special = 11 [default = false]; + */ + boolean getIsEnumSpecial(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.DescriptorReference} + */ + public static final class DescriptorReference extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.DescriptorReference) + DescriptorReferenceOrBuilder { + // Use DescriptorReference.newBuilder() to construct. + private DescriptorReference(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private DescriptorReference(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final DescriptorReference defaultInstance; + public static DescriptorReference getDefaultInstance() { + return defaultInstance; + } + + public DescriptorReference getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private DescriptorReference( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = packageFqName_.toBuilder(); + } + packageFqName_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(packageFqName_); + packageFqName_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = classFqName_.toBuilder(); + } + classFqName_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(classFqName_); + classFqName_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = uniqId_.toBuilder(); + } + uniqId_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(uniqId_); + uniqId_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 40: { + bitField0_ |= 0x00000010; + isGetter_ = input.readBool(); + break; + } + case 48: { + bitField0_ |= 0x00000020; + isSetter_ = input.readBool(); + break; + } + case 56: { + bitField0_ |= 0x00000040; + isBackingField_ = input.readBool(); + break; + } + case 64: { + bitField0_ |= 0x00000080; + isFakeOverride_ = input.readBool(); + break; + } + case 72: { + bitField0_ |= 0x00000100; + isDefaultConstructor_ = input.readBool(); + break; + } + case 80: { + bitField0_ |= 0x00000200; + isEnumEntry_ = input.readBool(); + break; + } + case 88: { + bitField0_ |= 0x00000400; + isEnumSpecial_ = input.readBool(); + 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 DescriptorReference parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new DescriptorReference(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int PACKAGE_FQ_NAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String packageFqName_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + public boolean hasPackageFqName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getPackageFqName() { + return packageFqName_; + } + + public static final int CLASS_FQ_NAME_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String classFqName_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + public boolean hasClassFqName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getClassFqName() { + return classFqName_; + } + + public static final int NAME_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + + public static final int UNIQ_ID_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId uniqId_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + public boolean hasUniqId() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getUniqId() { + return uniqId_; + } + + public static final int IS_GETTER_FIELD_NUMBER = 5; + private boolean isGetter_; + /** + * optional bool is_getter = 5 [default = false]; + */ + public boolean hasIsGetter() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bool is_getter = 5 [default = false]; + */ + public boolean getIsGetter() { + return isGetter_; + } + + public static final int IS_SETTER_FIELD_NUMBER = 6; + private boolean isSetter_; + /** + * optional bool is_setter = 6 [default = false]; + */ + public boolean hasIsSetter() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional bool is_setter = 6 [default = false]; + */ + public boolean getIsSetter() { + return isSetter_; + } + + public static final int IS_BACKING_FIELD_FIELD_NUMBER = 7; + private boolean isBackingField_; + /** + * optional bool is_backing_field = 7 [default = false]; + */ + public boolean hasIsBackingField() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional bool is_backing_field = 7 [default = false]; + */ + public boolean getIsBackingField() { + return isBackingField_; + } + + public static final int IS_FAKE_OVERRIDE_FIELD_NUMBER = 8; + private boolean isFakeOverride_; + /** + * optional bool is_fake_override = 8 [default = false]; + */ + public boolean hasIsFakeOverride() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional bool is_fake_override = 8 [default = false]; + */ + public boolean getIsFakeOverride() { + return isFakeOverride_; + } + + public static final int IS_DEFAULT_CONSTRUCTOR_FIELD_NUMBER = 9; + private boolean isDefaultConstructor_; + /** + * optional bool is_default_constructor = 9 [default = false]; + */ + public boolean hasIsDefaultConstructor() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * optional bool is_default_constructor = 9 [default = false]; + */ + public boolean getIsDefaultConstructor() { + return isDefaultConstructor_; + } + + public static final int IS_ENUM_ENTRY_FIELD_NUMBER = 10; + private boolean isEnumEntry_; + /** + * optional bool is_enum_entry = 10 [default = false]; + */ + public boolean hasIsEnumEntry() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * optional bool is_enum_entry = 10 [default = false]; + */ + public boolean getIsEnumEntry() { + return isEnumEntry_; + } + + public static final int IS_ENUM_SPECIAL_FIELD_NUMBER = 11; + private boolean isEnumSpecial_; + /** + * optional bool is_enum_special = 11 [default = false]; + */ + public boolean hasIsEnumSpecial() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional bool is_enum_special = 11 [default = false]; + */ + public boolean getIsEnumSpecial() { + return isEnumSpecial_; + } + + private void initFields() { + packageFqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + classFqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + uniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + isGetter_ = false; + isSetter_ = false; + isBackingField_ = false; + isFakeOverride_ = false; + isDefaultConstructor_ = false; + isEnumEntry_ = false; + isEnumSpecial_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasPackageFqName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasClassFqName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!getPackageFqName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getClassFqName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasUniqId()) { + if (!getUniqId().isInitialized()) { + 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.writeMessage(1, packageFqName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, classFqName_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, name_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, uniqId_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBool(5, isGetter_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeBool(6, isSetter_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeBool(7, isBackingField_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeBool(8, isFakeOverride_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + output.writeBool(9, isDefaultConstructor_); + } + if (((bitField0_ & 0x00000200) == 0x00000200)) { + output.writeBool(10, isEnumEntry_); + } + if (((bitField0_ & 0x00000400) == 0x00000400)) { + output.writeBool(11, isEnumSpecial_); + } + 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 + .computeMessageSize(1, packageFqName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, classFqName_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, name_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, uniqId_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(5, isGetter_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(6, isSetter_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(7, isBackingField_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(8, isFakeOverride_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(9, isDefaultConstructor_); + } + if (((bitField0_ & 0x00000200) == 0x00000200)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(10, isEnumEntry_); + } + if (((bitField0_ & 0x00000400) == 0x00000400)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(11, isEnumSpecial_); + } + 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.KotlinIr.DescriptorReference 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.KotlinIr.DescriptorReference 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.KotlinIr.DescriptorReference parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference 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.KotlinIr.DescriptorReference parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference 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.KotlinIr.DescriptorReference parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference 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.KotlinIr.DescriptorReference parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference 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.KotlinIr.DescriptorReference prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.DescriptorReference} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.DescriptorReference) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReferenceOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + packageFqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + classFqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + uniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + isGetter_ = false; + bitField0_ = (bitField0_ & ~0x00000010); + isSetter_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + isBackingField_ = false; + bitField0_ = (bitField0_ & ~0x00000040); + isFakeOverride_ = false; + bitField0_ = (bitField0_ & ~0x00000080); + isDefaultConstructor_ = false; + bitField0_ = (bitField0_ & ~0x00000100); + isEnumEntry_ = false; + bitField0_ = (bitField0_ & ~0x00000200); + isEnumSpecial_ = false; + bitField0_ = (bitField0_ & ~0x00000400); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.packageFqName_ = packageFqName_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.classFqName_ = classFqName_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.uniqId_ = uniqId_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.isGetter_ = isGetter_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.isSetter_ = isSetter_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + result.isBackingField_ = isBackingField_; + if (((from_bitField0_ & 0x00000080) == 0x00000080)) { + to_bitField0_ |= 0x00000080; + } + result.isFakeOverride_ = isFakeOverride_; + if (((from_bitField0_ & 0x00000100) == 0x00000100)) { + to_bitField0_ |= 0x00000100; + } + result.isDefaultConstructor_ = isDefaultConstructor_; + if (((from_bitField0_ & 0x00000200) == 0x00000200)) { + to_bitField0_ |= 0x00000200; + } + result.isEnumEntry_ = isEnumEntry_; + if (((from_bitField0_ & 0x00000400) == 0x00000400)) { + to_bitField0_ |= 0x00000400; + } + result.isEnumSpecial_ = isEnumSpecial_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance()) return this; + if (other.hasPackageFqName()) { + mergePackageFqName(other.getPackageFqName()); + } + if (other.hasClassFqName()) { + mergeClassFqName(other.getClassFqName()); + } + if (other.hasName()) { + mergeName(other.getName()); + } + if (other.hasUniqId()) { + mergeUniqId(other.getUniqId()); + } + if (other.hasIsGetter()) { + setIsGetter(other.getIsGetter()); + } + if (other.hasIsSetter()) { + setIsSetter(other.getIsSetter()); + } + if (other.hasIsBackingField()) { + setIsBackingField(other.getIsBackingField()); + } + if (other.hasIsFakeOverride()) { + setIsFakeOverride(other.getIsFakeOverride()); + } + if (other.hasIsDefaultConstructor()) { + setIsDefaultConstructor(other.getIsDefaultConstructor()); + } + if (other.hasIsEnumEntry()) { + setIsEnumEntry(other.getIsEnumEntry()); + } + if (other.hasIsEnumSpecial()) { + setIsEnumSpecial(other.getIsEnumSpecial()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasPackageFqName()) { + + return false; + } + if (!hasClassFqName()) { + + return false; + } + if (!hasName()) { + + return false; + } + if (!getPackageFqName().isInitialized()) { + + return false; + } + if (!getClassFqName().isInitialized()) { + + return false; + } + if (!getName().isInitialized()) { + + return false; + } + if (hasUniqId()) { + if (!getUniqId().isInitialized()) { + + 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.KotlinIr.DescriptorReference parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String packageFqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + public boolean hasPackageFqName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getPackageFqName() { + return packageFqName_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + public Builder setPackageFqName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + packageFqName_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + public Builder setPackageFqName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + packageFqName_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + public Builder mergePackageFqName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + packageFqName_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + packageFqName_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(packageFqName_).mergeFrom(value).buildPartial(); + } else { + packageFqName_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String package_fq_name = 1; + */ + public Builder clearPackageFqName() { + packageFqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String classFqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + public boolean hasClassFqName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getClassFqName() { + return classFqName_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + public Builder setClassFqName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + classFqName_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + public Builder setClassFqName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + classFqName_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + public Builder mergeClassFqName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + classFqName_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + classFqName_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(classFqName_).mergeFrom(value).buildPartial(); + } else { + classFqName_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String class_fq_name = 2; + */ + public Builder clearClassFqName() { + classFqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 3; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId uniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + public boolean hasUniqId() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getUniqId() { + return uniqId_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + public Builder setUniqId(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + uniqId_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + public Builder setUniqId( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.Builder builderForValue) { + uniqId_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + public Builder mergeUniqId(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + uniqId_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance()) { + uniqId_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.newBuilder(uniqId_).mergeFrom(value).buildPartial(); + } else { + uniqId_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 4; + */ + public Builder clearUniqId() { + uniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private boolean isGetter_ ; + /** + * optional bool is_getter = 5 [default = false]; + */ + public boolean hasIsGetter() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bool is_getter = 5 [default = false]; + */ + public boolean getIsGetter() { + return isGetter_; + } + /** + * optional bool is_getter = 5 [default = false]; + */ + public Builder setIsGetter(boolean value) { + bitField0_ |= 0x00000010; + isGetter_ = value; + + return this; + } + /** + * optional bool is_getter = 5 [default = false]; + */ + public Builder clearIsGetter() { + bitField0_ = (bitField0_ & ~0x00000010); + isGetter_ = false; + + return this; + } + + private boolean isSetter_ ; + /** + * optional bool is_setter = 6 [default = false]; + */ + public boolean hasIsSetter() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional bool is_setter = 6 [default = false]; + */ + public boolean getIsSetter() { + return isSetter_; + } + /** + * optional bool is_setter = 6 [default = false]; + */ + public Builder setIsSetter(boolean value) { + bitField0_ |= 0x00000020; + isSetter_ = value; + + return this; + } + /** + * optional bool is_setter = 6 [default = false]; + */ + public Builder clearIsSetter() { + bitField0_ = (bitField0_ & ~0x00000020); + isSetter_ = false; + + return this; + } + + private boolean isBackingField_ ; + /** + * optional bool is_backing_field = 7 [default = false]; + */ + public boolean hasIsBackingField() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional bool is_backing_field = 7 [default = false]; + */ + public boolean getIsBackingField() { + return isBackingField_; + } + /** + * optional bool is_backing_field = 7 [default = false]; + */ + public Builder setIsBackingField(boolean value) { + bitField0_ |= 0x00000040; + isBackingField_ = value; + + return this; + } + /** + * optional bool is_backing_field = 7 [default = false]; + */ + public Builder clearIsBackingField() { + bitField0_ = (bitField0_ & ~0x00000040); + isBackingField_ = false; + + return this; + } + + private boolean isFakeOverride_ ; + /** + * optional bool is_fake_override = 8 [default = false]; + */ + public boolean hasIsFakeOverride() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional bool is_fake_override = 8 [default = false]; + */ + public boolean getIsFakeOverride() { + return isFakeOverride_; + } + /** + * optional bool is_fake_override = 8 [default = false]; + */ + public Builder setIsFakeOverride(boolean value) { + bitField0_ |= 0x00000080; + isFakeOverride_ = value; + + return this; + } + /** + * optional bool is_fake_override = 8 [default = false]; + */ + public Builder clearIsFakeOverride() { + bitField0_ = (bitField0_ & ~0x00000080); + isFakeOverride_ = false; + + return this; + } + + private boolean isDefaultConstructor_ ; + /** + * optional bool is_default_constructor = 9 [default = false]; + */ + public boolean hasIsDefaultConstructor() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * optional bool is_default_constructor = 9 [default = false]; + */ + public boolean getIsDefaultConstructor() { + return isDefaultConstructor_; + } + /** + * optional bool is_default_constructor = 9 [default = false]; + */ + public Builder setIsDefaultConstructor(boolean value) { + bitField0_ |= 0x00000100; + isDefaultConstructor_ = value; + + return this; + } + /** + * optional bool is_default_constructor = 9 [default = false]; + */ + public Builder clearIsDefaultConstructor() { + bitField0_ = (bitField0_ & ~0x00000100); + isDefaultConstructor_ = false; + + return this; + } + + private boolean isEnumEntry_ ; + /** + * optional bool is_enum_entry = 10 [default = false]; + */ + public boolean hasIsEnumEntry() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * optional bool is_enum_entry = 10 [default = false]; + */ + public boolean getIsEnumEntry() { + return isEnumEntry_; + } + /** + * optional bool is_enum_entry = 10 [default = false]; + */ + public Builder setIsEnumEntry(boolean value) { + bitField0_ |= 0x00000200; + isEnumEntry_ = value; + + return this; + } + /** + * optional bool is_enum_entry = 10 [default = false]; + */ + public Builder clearIsEnumEntry() { + bitField0_ = (bitField0_ & ~0x00000200); + isEnumEntry_ = false; + + return this; + } + + private boolean isEnumSpecial_ ; + /** + * optional bool is_enum_special = 11 [default = false]; + */ + public boolean hasIsEnumSpecial() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional bool is_enum_special = 11 [default = false]; + */ + public boolean getIsEnumSpecial() { + return isEnumSpecial_; + } + /** + * optional bool is_enum_special = 11 [default = false]; + */ + public Builder setIsEnumSpecial(boolean value) { + bitField0_ |= 0x00000400; + isEnumSpecial_ = value; + + return this; + } + /** + * optional bool is_enum_special = 11 [default = false]; + */ + public Builder clearIsEnumSpecial() { + bitField0_ = (bitField0_ & ~0x00000400); + isEnumSpecial_ = false; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.DescriptorReference) + } + + static { + defaultInstance = new DescriptorReference(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.DescriptorReference) + } + + public interface UniqIdOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.UniqId) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required uint64 index = 1; + */ + boolean hasIndex(); + /** + * required uint64 index = 1; + */ + long getIndex(); + + /** + * required bool isLocal = 2; + */ + boolean hasIsLocal(); + /** + * required bool isLocal = 2; + */ + boolean getIsLocal(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.UniqId} + */ + public static final class UniqId extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.UniqId) + UniqIdOrBuilder { + // Use UniqId.newBuilder() to construct. + private UniqId(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private UniqId(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final UniqId defaultInstance; + public static UniqId getDefaultInstance() { + return defaultInstance; + } + + public UniqId getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private UniqId( + 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); + 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; + index_ = input.readUInt64(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + isLocal_ = input.readBool(); + 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 UniqId parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new UniqId(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int INDEX_FIELD_NUMBER = 1; + private long index_; + /** + * required uint64 index = 1; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required uint64 index = 1; + */ + public long getIndex() { + return index_; + } + + public static final int ISLOCAL_FIELD_NUMBER = 2; + private boolean isLocal_; + /** + * required bool isLocal = 2; + */ + public boolean hasIsLocal() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required bool isLocal = 2; + */ + public boolean getIsLocal() { + return isLocal_; + } + + private void initFields() { + index_ = 0L; + isLocal_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasIndex()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsLocal()) { + 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.writeUInt64(1, index_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBool(2, isLocal_); + } + 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 + .computeUInt64Size(1, index_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(2, isLocal_); + } + 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.KotlinIr.UniqId 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.KotlinIr.UniqId 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.KotlinIr.UniqId parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId 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.KotlinIr.UniqId parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId 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.KotlinIr.UniqId parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId 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.KotlinIr.UniqId parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId 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.KotlinIr.UniqId prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.UniqId} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.UniqId) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqIdOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + index_ = 0L; + bitField0_ = (bitField0_ & ~0x00000001); + isLocal_ = false; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.index_ = index_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.isLocal_ = isLocal_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance()) return this; + if (other.hasIndex()) { + setIndex(other.getIndex()); + } + if (other.hasIsLocal()) { + setIsLocal(other.getIsLocal()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasIndex()) { + + return false; + } + if (!hasIsLocal()) { + + 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.KotlinIr.UniqId parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private long index_ ; + /** + * required uint64 index = 1; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required uint64 index = 1; + */ + public long getIndex() { + return index_; + } + /** + * required uint64 index = 1; + */ + public Builder setIndex(long value) { + bitField0_ |= 0x00000001; + index_ = value; + + return this; + } + /** + * required uint64 index = 1; + */ + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000001); + index_ = 0L; + + return this; + } + + private boolean isLocal_ ; + /** + * required bool isLocal = 2; + */ + public boolean hasIsLocal() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required bool isLocal = 2; + */ + public boolean getIsLocal() { + return isLocal_; + } + /** + * required bool isLocal = 2; + */ + public Builder setIsLocal(boolean value) { + bitField0_ |= 0x00000002; + isLocal_ = value; + + return this; + } + /** + * required bool isLocal = 2; + */ + public Builder clearIsLocal() { + bitField0_ = (bitField0_ & ~0x00000002); + isLocal_ = false; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.UniqId) + } + + static { + defaultInstance = new UniqId(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.UniqId) + } + + public interface CoordinatesOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.Coordinates) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 start_offset = 1; + */ + boolean hasStartOffset(); + /** + * required int32 start_offset = 1; + */ + int getStartOffset(); + + /** + * required int32 end_offset = 2; + */ + boolean hasEndOffset(); + /** + * required int32 end_offset = 2; + */ + int getEndOffset(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Coordinates} + */ + public static final class Coordinates extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.Coordinates) + CoordinatesOrBuilder { + // Use Coordinates.newBuilder() to construct. + private Coordinates(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Coordinates(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final Coordinates defaultInstance; + public static Coordinates getDefaultInstance() { + return defaultInstance; + } + + public Coordinates getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private Coordinates( + 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); + 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; + startOffset_ = input.readInt32(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + endOffset_ = 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 Coordinates parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new Coordinates(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int START_OFFSET_FIELD_NUMBER = 1; + private int startOffset_; + /** + * required int32 start_offset = 1; + */ + public boolean hasStartOffset() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 start_offset = 1; + */ + public int getStartOffset() { + return startOffset_; + } + + public static final int END_OFFSET_FIELD_NUMBER = 2; + private int endOffset_; + /** + * required int32 end_offset = 2; + */ + public boolean hasEndOffset() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 end_offset = 2; + */ + public int getEndOffset() { + return endOffset_; + } + + private void initFields() { + startOffset_ = 0; + endOffset_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasStartOffset()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasEndOffset()) { + 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, startOffset_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, endOffset_); + } + 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, startOffset_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32Size(2, endOffset_); + } + 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.KotlinIr.Coordinates 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.KotlinIr.Coordinates 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.KotlinIr.Coordinates parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates 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.KotlinIr.Coordinates parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates 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.KotlinIr.Coordinates parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates 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.KotlinIr.Coordinates parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates 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.KotlinIr.Coordinates prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Coordinates} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.Coordinates) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.CoordinatesOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + startOffset_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + endOffset_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.startOffset_ = startOffset_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.endOffset_ = endOffset_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance()) return this; + if (other.hasStartOffset()) { + setStartOffset(other.getStartOffset()); + } + if (other.hasEndOffset()) { + setEndOffset(other.getEndOffset()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasStartOffset()) { + + return false; + } + if (!hasEndOffset()) { + + 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.KotlinIr.Coordinates parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int startOffset_ ; + /** + * required int32 start_offset = 1; + */ + public boolean hasStartOffset() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 start_offset = 1; + */ + public int getStartOffset() { + return startOffset_; + } + /** + * required int32 start_offset = 1; + */ + public Builder setStartOffset(int value) { + bitField0_ |= 0x00000001; + startOffset_ = value; + + return this; + } + /** + * required int32 start_offset = 1; + */ + public Builder clearStartOffset() { + bitField0_ = (bitField0_ & ~0x00000001); + startOffset_ = 0; + + return this; + } + + private int endOffset_ ; + /** + * required int32 end_offset = 2; + */ + public boolean hasEndOffset() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 end_offset = 2; + */ + public int getEndOffset() { + return endOffset_; + } + /** + * required int32 end_offset = 2; + */ + public Builder setEndOffset(int value) { + bitField0_ |= 0x00000002; + endOffset_ = value; + + return this; + } + /** + * required int32 end_offset = 2; + */ + public Builder clearEndOffset() { + bitField0_ = (bitField0_ & ~0x00000002); + endOffset_ = 0; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.Coordinates) + } + + static { + defaultInstance = new Coordinates(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.Coordinates) + } + + public interface VisibilityOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.Visibility) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Visibility} + */ + public static final class Visibility extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.Visibility) + VisibilityOrBuilder { + // Use Visibility.newBuilder() to construct. + private Visibility(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Visibility(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final Visibility defaultInstance; + public static Visibility getDefaultInstance() { + return defaultInstance; + } + + public Visibility getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private Visibility( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 Visibility parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new Visibility(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + + private void initFields() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + 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.writeMessage(1, name_); + } + 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 + .computeMessageSize(1, name_); + } + 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.KotlinIr.Visibility 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.KotlinIr.Visibility 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.KotlinIr.Visibility parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility 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.KotlinIr.Visibility parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility 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.KotlinIr.Visibility parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility 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.KotlinIr.Visibility parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility 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.KotlinIr.Visibility prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Visibility} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.Visibility) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.VisibilityOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance()) return this; + if (other.hasName()) { + mergeName(other.getName()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!getName().isInitialized()) { + + 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.KotlinIr.Visibility parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.Visibility) + } + + static { + defaultInstance = new Visibility(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.Visibility) + } + + public interface IrStatementOriginOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin} + */ + public static final class IrStatementOrigin extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin) + IrStatementOriginOrBuilder { + // Use IrStatementOrigin.newBuilder() to construct. + private IrStatementOrigin(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrStatementOrigin(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrStatementOrigin defaultInstance; + public static IrStatementOrigin getDefaultInstance() { + return defaultInstance; + } + + public IrStatementOrigin getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrStatementOrigin( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrStatementOrigin parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrStatementOrigin(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + + private void initFields() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + 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.writeMessage(1, name_); + } + 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 + .computeMessageSize(1, name_); + } + 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.KotlinIr.IrStatementOrigin 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.KotlinIr.IrStatementOrigin 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.KotlinIr.IrStatementOrigin parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin 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.KotlinIr.IrStatementOrigin parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin 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.KotlinIr.IrStatementOrigin parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin 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.KotlinIr.IrStatementOrigin parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin 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.KotlinIr.IrStatementOrigin prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOriginOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) return this; + if (other.hasName()) { + mergeName(other.getName()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!getName().isInitialized()) { + + 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.KotlinIr.IrStatementOrigin parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin) + } + + static { + defaultInstance = new IrStatementOrigin(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin) + } + + public interface IrDeclarationOriginOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.KnownOrigin origin = 1; + */ + boolean hasOrigin(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.KnownOrigin origin = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin getOrigin(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + boolean hasCustom(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getCustom(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin} + */ + public static final class IrDeclarationOrigin extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin) + IrDeclarationOriginOrBuilder { + // Use IrDeclarationOrigin.newBuilder() to construct. + private IrDeclarationOrigin(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDeclarationOrigin(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDeclarationOrigin defaultInstance; + public static IrDeclarationOrigin getDefaultInstance() { + return defaultInstance; + } + + public IrDeclarationOrigin getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDeclarationOrigin( + 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); + 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: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + eitherCase_ = 1; + either_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (eitherCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) either_).toBuilder(); + } + either_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) either_); + either_ = subBuilder.buildPartial(); + } + eitherCase_ = 2; + 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 IrDeclarationOrigin parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDeclarationOrigin(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + private int eitherCase_ = 0; + private java.lang.Object either_; + public enum EitherCase + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + ORIGIN(1), + CUSTOM(2), + EITHER_NOT_SET(0); + private int value = 0; + private EitherCase(int value) { + this.value = value; + } + public static EitherCase valueOf(int value) { + switch (value) { + case 1: return ORIGIN; + case 2: return CUSTOM; + case 0: return EITHER_NOT_SET; + default: throw new java.lang.IllegalArgumentException( + "Value is undefined for this oneof enum."); + } + } + public int getNumber() { + return this.value; + } + }; + + public EitherCase + getEitherCase() { + return EitherCase.valueOf( + eitherCase_); + } + + public static final int ORIGIN_FIELD_NUMBER = 1; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.KnownOrigin origin = 1; + */ + public boolean hasOrigin() { + return eitherCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.KnownOrigin origin = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin getOrigin() { + if (eitherCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin) either_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin.CUSTOM; + } + + public static final int CUSTOM_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + public boolean hasCustom() { + return eitherCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getCustom() { + if (eitherCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) either_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + } + + private void initFields() { + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (hasCustom()) { + if (!getCustom().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (eitherCase_ == 1) { + output.writeEnum(1, ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin) either_).getNumber()); + } + if (eitherCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) either_); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (eitherCase_ == 1) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeEnumSize(1, ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin) either_).getNumber()); + } + if (eitherCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) either_); + } + 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.KotlinIr.IrDeclarationOrigin 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.KotlinIr.IrDeclarationOrigin 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.KotlinIr.IrDeclarationOrigin parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin 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.KotlinIr.IrDeclarationOrigin parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin 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.KotlinIr.IrDeclarationOrigin parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin 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.KotlinIr.IrDeclarationOrigin parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin 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.KotlinIr.IrDeclarationOrigin prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOriginOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + eitherCase_ = 0; + either_ = null; + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (eitherCase_ == 1) { + result.either_ = either_; + } + if (eitherCase_ == 2) { + result.either_ = either_; + } + result.bitField0_ = to_bitField0_; + result.eitherCase_ = eitherCase_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.getDefaultInstance()) return this; + switch (other.getEitherCase()) { + case ORIGIN: { + setOrigin(other.getOrigin()); + break; + } + case CUSTOM: { + mergeCustom(other.getCustom()); + break; + } + case EITHER_NOT_SET: { + break; + } + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (hasCustom()) { + if (!getCustom().isInitialized()) { + + 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.KotlinIr.IrDeclarationOrigin parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int eitherCase_ = 0; + private java.lang.Object either_; + public EitherCase + getEitherCase() { + return EitherCase.valueOf( + eitherCase_); + } + + public Builder clearEither() { + eitherCase_ = 0; + either_ = null; + return this; + } + + private int bitField0_; + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.KnownOrigin origin = 1; + */ + public boolean hasOrigin() { + return eitherCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.KnownOrigin origin = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin getOrigin() { + if (eitherCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin) either_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin.CUSTOM; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.KnownOrigin origin = 1; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.KnownOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + eitherCase_ = 1; + either_ = value; + + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.KnownOrigin origin = 1; + */ + public Builder clearOrigin() { + if (eitherCase_ == 1) { + eitherCase_ = 0; + either_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + public boolean hasCustom() { + return eitherCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getCustom() { + if (eitherCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) either_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + public Builder setCustom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + either_ = value; + + eitherCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + public Builder setCustom( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + either_ = builderForValue.build(); + + eitherCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + public Builder mergeCustom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (eitherCase_ == 2 && + either_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + either_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) either_) + .mergeFrom(value).buildPartial(); + } else { + either_ = value; + } + + eitherCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String custom = 2; + */ + public Builder clearCustom() { + if (eitherCase_ == 2) { + eitherCase_ = 0; + either_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin) + } + + static { + defaultInstance = new IrDeclarationOrigin(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin) + } + + public interface NameOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.Name) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName(); + + /** + * required bool is_special = 2; + */ + boolean hasIsSpecial(); + /** + * required bool is_special = 2; + */ + boolean getIsSpecial(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Name} + */ + public static final class Name extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.Name) + NameOrBuilder { + // Use Name.newBuilder() to construct. + private Name(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Name(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final Name defaultInstance; + public static Name getDefaultInstance() { + return defaultInstance; + } + + public Name getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private Name( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + bitField0_ |= 0x00000002; + isSpecial_ = input.readBool(); + 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 Name parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new Name(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + + public static final int IS_SPECIAL_FIELD_NUMBER = 2; + private boolean isSpecial_; + /** + * required bool is_special = 2; + */ + public boolean hasIsSpecial() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required bool is_special = 2; + */ + public boolean getIsSpecial() { + return isSpecial_; + } + + private void initFields() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + isSpecial_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsSpecial()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + 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.writeMessage(1, name_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBool(2, isSpecial_); + } + 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 + .computeMessageSize(1, name_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(2, isSpecial_); + } + 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.KotlinIr.Name 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.KotlinIr.Name 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.KotlinIr.Name parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name 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.KotlinIr.Name parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name 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.KotlinIr.Name parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name 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.KotlinIr.Name parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name 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.KotlinIr.Name prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Name} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.Name) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NameOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + isSpecial_ = false; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.isSpecial_ = isSpecial_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) return this; + if (other.hasName()) { + mergeName(other.getName()); + } + if (other.hasIsSpecial()) { + setIsSpecial(other.getIsSpecial()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!hasIsSpecial()) { + + return false; + } + if (!getName().isInitialized()) { + + 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.KotlinIr.Name parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private boolean isSpecial_ ; + /** + * required bool is_special = 2; + */ + public boolean hasIsSpecial() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required bool is_special = 2; + */ + public boolean getIsSpecial() { + return isSpecial_; + } + /** + * required bool is_special = 2; + */ + public Builder setIsSpecial(boolean value) { + bitField0_ |= 0x00000002; + isSpecial_ = value; + + return this; + } + /** + * required bool is_special = 2; + */ + public Builder clearIsSpecial() { + bitField0_ = (bitField0_ & ~0x00000002); + isSpecial_ = false; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.Name) + } + + static { + defaultInstance = new Name(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.Name) + } + + public interface IrDeclarationContainerOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + java.util.List + getDeclarationList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDeclaration(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + int getDeclarationCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer} + */ + public static final class IrDeclarationContainer extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer) + IrDeclarationContainerOrBuilder { + // Use IrDeclarationContainer.newBuilder() to construct. + private IrDeclarationContainer(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDeclarationContainer(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDeclarationContainer defaultInstance; + public static IrDeclarationContainer getDefaultInstance() { + return defaultInstance; + } + + public IrDeclarationContainer getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDeclarationContainer( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + declaration_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + declaration_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + declaration_ = java.util.Collections.unmodifiableList(declaration_); + } + 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 IrDeclarationContainer parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDeclarationContainer(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int DECLARATION_FIELD_NUMBER = 1; + private java.util.List declaration_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public java.util.List getDeclarationList() { + return declaration_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public java.util.List + getDeclarationOrBuilderList() { + return declaration_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public int getDeclarationCount() { + return declaration_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDeclaration(int index) { + return declaration_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrBuilder getDeclarationOrBuilder( + int index) { + return declaration_.get(index); + } + + private void initFields() { + declaration_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getDeclarationCount(); i++) { + if (!getDeclaration(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < declaration_.size(); i++) { + output.writeMessage(1, declaration_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < declaration_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, declaration_.get(i)); + } + 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.KotlinIr.IrDeclarationContainer 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.KotlinIr.IrDeclarationContainer 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.KotlinIr.IrDeclarationContainer parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer 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.KotlinIr.IrDeclarationContainer parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer 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.KotlinIr.IrDeclarationContainer parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer 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.KotlinIr.IrDeclarationContainer parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer 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.KotlinIr.IrDeclarationContainer prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainerOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + declaration_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + declaration_ = java.util.Collections.unmodifiableList(declaration_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.declaration_ = declaration_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.getDefaultInstance()) return this; + if (!other.declaration_.isEmpty()) { + if (declaration_.isEmpty()) { + declaration_ = other.declaration_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureDeclarationIsMutable(); + declaration_.addAll(other.declaration_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getDeclarationCount(); i++) { + if (!getDeclaration(i).isInitialized()) { + + 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.KotlinIr.IrDeclarationContainer parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List declaration_ = + java.util.Collections.emptyList(); + private void ensureDeclarationIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + declaration_ = new java.util.ArrayList(declaration_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public java.util.List getDeclarationList() { + return java.util.Collections.unmodifiableList(declaration_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public int getDeclarationCount() { + return declaration_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDeclaration(int index) { + return declaration_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public Builder setDeclaration( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIsMutable(); + declaration_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public Builder setDeclaration( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + ensureDeclarationIsMutable(); + declaration_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public Builder addDeclaration(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIsMutable(); + declaration_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public Builder addDeclaration( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIsMutable(); + declaration_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public Builder addDeclaration( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + ensureDeclarationIsMutable(); + declaration_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public Builder addDeclaration( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + ensureDeclarationIsMutable(); + declaration_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public Builder addAllDeclaration( + java.lang.Iterable values) { + ensureDeclarationIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, declaration_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public Builder clearDeclaration() { + declaration_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 1; + */ + public Builder removeDeclaration(int index) { + ensureDeclarationIsMutable(); + declaration_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer) + } + + static { + defaultInstance = new IrDeclarationContainer(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer) + } + + public interface FileEntryOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.FileEntry) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName(); + + /** + * repeated int32 line_start_offsets = 2; + */ + java.util.List getLineStartOffsetsList(); + /** + * repeated int32 line_start_offsets = 2; + */ + int getLineStartOffsetsCount(); + /** + * repeated int32 line_start_offsets = 2; + */ + int getLineStartOffsets(int index); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.FileEntry} + */ + public static final class FileEntry extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.FileEntry) + FileEntryOrBuilder { + // Use FileEntry.newBuilder() to construct. + private FileEntry(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private FileEntry(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final FileEntry defaultInstance; + public static FileEntry getDefaultInstance() { + return defaultInstance; + } + + public FileEntry getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private FileEntry( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + lineStartOffsets_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + lineStartOffsets_.add(input.readInt32()); + break; + } + case 18: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) { + lineStartOffsets_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + while (input.getBytesUntilLimit() > 0) { + lineStartOffsets_.add(input.readInt32()); + } + input.popLimit(limit); + 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 { + if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + lineStartOffsets_ = java.util.Collections.unmodifiableList(lineStartOffsets_); + } + 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 FileEntry parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new FileEntry(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + + public static final int LINE_START_OFFSETS_FIELD_NUMBER = 2; + private java.util.List lineStartOffsets_; + /** + * repeated int32 line_start_offsets = 2; + */ + public java.util.List + getLineStartOffsetsList() { + return lineStartOffsets_; + } + /** + * repeated int32 line_start_offsets = 2; + */ + public int getLineStartOffsetsCount() { + return lineStartOffsets_.size(); + } + /** + * repeated int32 line_start_offsets = 2; + */ + public int getLineStartOffsets(int index) { + return lineStartOffsets_.get(index); + } + + private void initFields() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + lineStartOffsets_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + 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.writeMessage(1, name_); + } + for (int i = 0; i < lineStartOffsets_.size(); i++) { + output.writeInt32(2, lineStartOffsets_.get(i)); + } + 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 + .computeMessageSize(1, name_); + } + { + int dataSize = 0; + for (int i = 0; i < lineStartOffsets_.size(); i++) { + dataSize += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32SizeNoTag(lineStartOffsets_.get(i)); + } + size += dataSize; + size += 1 * getLineStartOffsetsList().size(); + } + 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.KotlinIr.FileEntry 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.KotlinIr.FileEntry 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.KotlinIr.FileEntry parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry 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.KotlinIr.FileEntry parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry 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.KotlinIr.FileEntry parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry 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.KotlinIr.FileEntry parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry 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.KotlinIr.FileEntry prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.FileEntry} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.FileEntry) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntryOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + lineStartOffsets_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + lineStartOffsets_ = java.util.Collections.unmodifiableList(lineStartOffsets_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.lineStartOffsets_ = lineStartOffsets_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.getDefaultInstance()) return this; + if (other.hasName()) { + mergeName(other.getName()); + } + if (!other.lineStartOffsets_.isEmpty()) { + if (lineStartOffsets_.isEmpty()) { + lineStartOffsets_ = other.lineStartOffsets_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureLineStartOffsetsIsMutable(); + lineStartOffsets_.addAll(other.lineStartOffsets_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!getName().isInitialized()) { + + 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.KotlinIr.FileEntry parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String name = 1; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private java.util.List lineStartOffsets_ = java.util.Collections.emptyList(); + private void ensureLineStartOffsetsIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + lineStartOffsets_ = new java.util.ArrayList(lineStartOffsets_); + bitField0_ |= 0x00000002; + } + } + /** + * repeated int32 line_start_offsets = 2; + */ + public java.util.List + getLineStartOffsetsList() { + return java.util.Collections.unmodifiableList(lineStartOffsets_); + } + /** + * repeated int32 line_start_offsets = 2; + */ + public int getLineStartOffsetsCount() { + return lineStartOffsets_.size(); + } + /** + * repeated int32 line_start_offsets = 2; + */ + public int getLineStartOffsets(int index) { + return lineStartOffsets_.get(index); + } + /** + * repeated int32 line_start_offsets = 2; + */ + public Builder setLineStartOffsets( + int index, int value) { + ensureLineStartOffsetsIsMutable(); + lineStartOffsets_.set(index, value); + + return this; + } + /** + * repeated int32 line_start_offsets = 2; + */ + public Builder addLineStartOffsets(int value) { + ensureLineStartOffsetsIsMutable(); + lineStartOffsets_.add(value); + + return this; + } + /** + * repeated int32 line_start_offsets = 2; + */ + public Builder addAllLineStartOffsets( + java.lang.Iterable values) { + ensureLineStartOffsetsIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, lineStartOffsets_); + + return this; + } + /** + * repeated int32 line_start_offsets = 2; + */ + public Builder clearLineStartOffsets() { + lineStartOffsets_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.FileEntry) + } + + static { + defaultInstance = new FileEntry(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.FileEntry) + } + + public interface IrFileOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrFile) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + java.util.List + getDeclarationIdList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getDeclarationId(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + int getDeclarationIdCount(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + boolean hasFileEntry(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry getFileEntry(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + boolean hasFqName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getFqName(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + boolean hasAnnotations(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + java.util.List + getExplicitlyExportedToCompilerList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getExplicitlyExportedToCompiler(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + int getExplicitlyExportedToCompilerCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrFile} + */ + public static final class IrFile extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrFile) + IrFileOrBuilder { + // Use IrFile.newBuilder() to construct. + private IrFile(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrFile(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrFile defaultInstance; + public static IrFile getDefaultInstance() { + return defaultInstance; + } + + public IrFile getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrFile( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + declarationId_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + declarationId_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.PARSER, extensionRegistry)); + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = fileEntry_.toBuilder(); + } + fileEntry_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(fileEntry_); + fileEntry_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = fqName_.toBuilder(); + } + fqName_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(fqName_); + fqName_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = annotations_.toBuilder(); + } + annotations_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(annotations_); + annotations_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 42: { + if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + explicitlyExportedToCompiler_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000010; + } + explicitlyExportedToCompiler_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + declarationId_ = java.util.Collections.unmodifiableList(declarationId_); + } + if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + explicitlyExportedToCompiler_ = java.util.Collections.unmodifiableList(explicitlyExportedToCompiler_); + } + 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 IrFile parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrFile(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int DECLARATION_ID_FIELD_NUMBER = 1; + private java.util.List declarationId_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public java.util.List getDeclarationIdList() { + return declarationId_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public java.util.List + getDeclarationIdOrBuilderList() { + return declarationId_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public int getDeclarationIdCount() { + return declarationId_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getDeclarationId(int index) { + return declarationId_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqIdOrBuilder getDeclarationIdOrBuilder( + int index) { + return declarationId_.get(index); + } + + public static final int FILE_ENTRY_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry fileEntry_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + public boolean hasFileEntry() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry getFileEntry() { + return fileEntry_; + } + + public static final int FQ_NAME_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String fqName_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + public boolean hasFqName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getFqName() { + return fqName_; + } + + public static final int ANNOTATIONS_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + + public static final int EXPLICITLY_EXPORTED_TO_COMPILER_FIELD_NUMBER = 5; + private java.util.List explicitlyExportedToCompiler_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public java.util.List getExplicitlyExportedToCompilerList() { + return explicitlyExportedToCompiler_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public java.util.List + getExplicitlyExportedToCompilerOrBuilderList() { + return explicitlyExportedToCompiler_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public int getExplicitlyExportedToCompilerCount() { + return explicitlyExportedToCompiler_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getExplicitlyExportedToCompiler(int index) { + return explicitlyExportedToCompiler_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolOrBuilder getExplicitlyExportedToCompilerOrBuilder( + int index) { + return explicitlyExportedToCompiler_.get(index); + } + + private void initFields() { + declarationId_ = java.util.Collections.emptyList(); + fileEntry_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.getDefaultInstance(); + fqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + explicitlyExportedToCompiler_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasFileEntry()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasFqName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasAnnotations()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getDeclarationIdCount(); i++) { + if (!getDeclarationId(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getFileEntry().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getFqName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getAnnotations().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getExplicitlyExportedToCompilerCount(); i++) { + if (!getExplicitlyExportedToCompiler(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < declarationId_.size(); i++) { + output.writeMessage(1, declarationId_.get(i)); + } + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(2, fileEntry_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(3, fqName_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(4, annotations_); + } + for (int i = 0; i < explicitlyExportedToCompiler_.size(); i++) { + output.writeMessage(5, explicitlyExportedToCompiler_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < declarationId_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, declarationId_.get(i)); + } + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, fileEntry_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, fqName_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, annotations_); + } + for (int i = 0; i < explicitlyExportedToCompiler_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, explicitlyExportedToCompiler_.get(i)); + } + 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.KotlinIr.IrFile 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.KotlinIr.IrFile 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.KotlinIr.IrFile parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile 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.KotlinIr.IrFile parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile 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.KotlinIr.IrFile parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile 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.KotlinIr.IrFile parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile 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.KotlinIr.IrFile prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrFile} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrFile) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFileOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + declarationId_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + fileEntry_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + fqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + explicitlyExportedToCompiler_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + declarationId_ = java.util.Collections.unmodifiableList(declarationId_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.declarationId_ = declarationId_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000001; + } + result.fileEntry_ = fileEntry_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000002; + } + result.fqName_ = fqName_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000004; + } + result.annotations_ = annotations_; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + explicitlyExportedToCompiler_ = java.util.Collections.unmodifiableList(explicitlyExportedToCompiler_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.explicitlyExportedToCompiler_ = explicitlyExportedToCompiler_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile.getDefaultInstance()) return this; + if (!other.declarationId_.isEmpty()) { + if (declarationId_.isEmpty()) { + declarationId_ = other.declarationId_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureDeclarationIdIsMutable(); + declarationId_.addAll(other.declarationId_); + } + + } + if (other.hasFileEntry()) { + mergeFileEntry(other.getFileEntry()); + } + if (other.hasFqName()) { + mergeFqName(other.getFqName()); + } + if (other.hasAnnotations()) { + mergeAnnotations(other.getAnnotations()); + } + if (!other.explicitlyExportedToCompiler_.isEmpty()) { + if (explicitlyExportedToCompiler_.isEmpty()) { + explicitlyExportedToCompiler_ = other.explicitlyExportedToCompiler_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureExplicitlyExportedToCompilerIsMutable(); + explicitlyExportedToCompiler_.addAll(other.explicitlyExportedToCompiler_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasFileEntry()) { + + return false; + } + if (!hasFqName()) { + + return false; + } + if (!hasAnnotations()) { + + return false; + } + for (int i = 0; i < getDeclarationIdCount(); i++) { + if (!getDeclarationId(i).isInitialized()) { + + return false; + } + } + if (!getFileEntry().isInitialized()) { + + return false; + } + if (!getFqName().isInitialized()) { + + return false; + } + if (!getAnnotations().isInitialized()) { + + return false; + } + for (int i = 0; i < getExplicitlyExportedToCompilerCount(); i++) { + if (!getExplicitlyExportedToCompiler(i).isInitialized()) { + + 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.KotlinIr.IrFile parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List declarationId_ = + java.util.Collections.emptyList(); + private void ensureDeclarationIdIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + declarationId_ = new java.util.ArrayList(declarationId_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public java.util.List getDeclarationIdList() { + return java.util.Collections.unmodifiableList(declarationId_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public int getDeclarationIdCount() { + return declarationId_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getDeclarationId(int index) { + return declarationId_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public Builder setDeclarationId( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIdIsMutable(); + declarationId_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public Builder setDeclarationId( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.Builder builderForValue) { + ensureDeclarationIdIsMutable(); + declarationId_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public Builder addDeclarationId(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIdIsMutable(); + declarationId_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public Builder addDeclarationId( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIdIsMutable(); + declarationId_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public Builder addDeclarationId( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.Builder builderForValue) { + ensureDeclarationIdIsMutable(); + declarationId_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public Builder addDeclarationId( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.Builder builderForValue) { + ensureDeclarationIdIsMutable(); + declarationId_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public Builder addAllDeclarationId( + java.lang.Iterable values) { + ensureDeclarationIdIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, declarationId_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public Builder clearDeclarationId() { + declarationId_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.UniqId declaration_id = 1; + */ + public Builder removeDeclarationId(int index) { + ensureDeclarationIdIsMutable(); + declarationId_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry fileEntry_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + public boolean hasFileEntry() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry getFileEntry() { + return fileEntry_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + public Builder setFileEntry(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry value) { + if (value == null) { + throw new NullPointerException(); + } + fileEntry_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + public Builder setFileEntry( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.Builder builderForValue) { + fileEntry_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + public Builder mergeFileEntry(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + fileEntry_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.getDefaultInstance()) { + fileEntry_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.newBuilder(fileEntry_).mergeFrom(value).buildPartial(); + } else { + fileEntry_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FileEntry file_entry = 2; + */ + public Builder clearFileEntry() { + fileEntry_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FileEntry.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String fqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + public boolean hasFqName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getFqName() { + return fqName_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + public Builder setFqName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + fqName_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + public Builder setFqName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + fqName_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + public Builder mergeFqName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + fqName_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + fqName_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(fqName_).mergeFrom(value).buildPartial(); + } else { + fqName_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String fq_name = 3; + */ + public Builder clearFqName() { + fqName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + public Builder setAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (value == null) { + throw new NullPointerException(); + } + annotations_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + public Builder setAnnotations( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder builderForValue) { + annotations_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + public Builder mergeAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + annotations_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance()) { + annotations_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.newBuilder(annotations_).mergeFrom(value).buildPartial(); + } else { + annotations_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 4; + */ + public Builder clearAnnotations() { + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private java.util.List explicitlyExportedToCompiler_ = + java.util.Collections.emptyList(); + private void ensureExplicitlyExportedToCompilerIsMutable() { + if (!((bitField0_ & 0x00000010) == 0x00000010)) { + explicitlyExportedToCompiler_ = new java.util.ArrayList(explicitlyExportedToCompiler_); + bitField0_ |= 0x00000010; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public java.util.List getExplicitlyExportedToCompilerList() { + return java.util.Collections.unmodifiableList(explicitlyExportedToCompiler_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public int getExplicitlyExportedToCompilerCount() { + return explicitlyExportedToCompiler_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getExplicitlyExportedToCompiler(int index) { + return explicitlyExportedToCompiler_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public Builder setExplicitlyExportedToCompiler( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + ensureExplicitlyExportedToCompilerIsMutable(); + explicitlyExportedToCompiler_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public Builder setExplicitlyExportedToCompiler( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + ensureExplicitlyExportedToCompilerIsMutable(); + explicitlyExportedToCompiler_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public Builder addExplicitlyExportedToCompiler(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + ensureExplicitlyExportedToCompilerIsMutable(); + explicitlyExportedToCompiler_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public Builder addExplicitlyExportedToCompiler( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + ensureExplicitlyExportedToCompilerIsMutable(); + explicitlyExportedToCompiler_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public Builder addExplicitlyExportedToCompiler( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + ensureExplicitlyExportedToCompilerIsMutable(); + explicitlyExportedToCompiler_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public Builder addExplicitlyExportedToCompiler( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + ensureExplicitlyExportedToCompilerIsMutable(); + explicitlyExportedToCompiler_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public Builder addAllExplicitlyExportedToCompiler( + java.lang.Iterable values) { + ensureExplicitlyExportedToCompilerIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, explicitlyExportedToCompiler_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public Builder clearExplicitlyExportedToCompiler() { + explicitlyExportedToCompiler_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol explicitly_exported_to_compiler = 5; + */ + public Builder removeExplicitlyExportedToCompiler(int index) { + ensureExplicitlyExportedToCompilerIsMutable(); + explicitlyExportedToCompiler_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrFile) + } + + static { + defaultInstance = new IrFile(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrFile) + } + + public interface IrModuleOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrModule) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + java.util.List + getFileList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile getFile(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + int getFileCount(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + boolean hasSymbolTable(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable getSymbolTable(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + boolean hasTypeTable(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable getTypeTable(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + boolean hasStringTable(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable getStringTable(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrModule} + */ + public static final class IrModule extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrModule) + IrModuleOrBuilder { + // Use IrModule.newBuilder() to construct. + private IrModule(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrModule(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrModule defaultInstance; + public static IrModule getDefaultInstance() { + return defaultInstance; + } + + public IrModule getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrModule( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + file_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + file_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile.PARSER, extensionRegistry)); + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = symbolTable_.toBuilder(); + } + symbolTable_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbolTable_); + symbolTable_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = typeTable_.toBuilder(); + } + typeTable_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(typeTable_); + typeTable_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = stringTable_.toBuilder(); + } + stringTable_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(stringTable_); + stringTable_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + 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 { + if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + file_ = java.util.Collections.unmodifiableList(file_); + } + 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 IrModule parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrModule(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + + public static final int FILE_FIELD_NUMBER = 2; + private java.util.List file_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public java.util.List getFileList() { + return file_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public java.util.List + getFileOrBuilderList() { + return file_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public int getFileCount() { + return file_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile getFile(int index) { + return file_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFileOrBuilder getFileOrBuilder( + int index) { + return file_.get(index); + } + + public static final int SYMBOL_TABLE_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable symbolTable_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + public boolean hasSymbolTable() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable getSymbolTable() { + return symbolTable_; + } + + public static final int TYPE_TABLE_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable typeTable_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + public boolean hasTypeTable() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable getTypeTable() { + return typeTable_; + } + + public static final int STRING_TABLE_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable stringTable_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + public boolean hasStringTable() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable getStringTable() { + return stringTable_; + } + + private void initFields() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + file_ = java.util.Collections.emptyList(); + symbolTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.getDefaultInstance(); + typeTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.getDefaultInstance(); + stringTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasSymbolTable()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasTypeTable()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasStringTable()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getFileCount(); i++) { + if (!getFile(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getSymbolTable().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getTypeTable().isInitialized()) { + 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.writeMessage(1, name_); + } + for (int i = 0; i < file_.size(); i++) { + output.writeMessage(2, file_.get(i)); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(3, symbolTable_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(4, typeTable_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(5, stringTable_); + } + 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 + .computeMessageSize(1, name_); + } + for (int i = 0; i < file_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, file_.get(i)); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, symbolTable_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, typeTable_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, stringTable_); + } + 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.KotlinIr.IrModule 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.KotlinIr.IrModule 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.KotlinIr.IrModule parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule 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.KotlinIr.IrModule parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule 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.KotlinIr.IrModule parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule 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.KotlinIr.IrModule parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule 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.KotlinIr.IrModule prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrModule} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrModule) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModuleOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + file_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + symbolTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + typeTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + stringTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + file_ = java.util.Collections.unmodifiableList(file_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.file_ = file_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000002; + } + result.symbolTable_ = symbolTable_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000004; + } + result.typeTable_ = typeTable_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000008; + } + result.stringTable_ = stringTable_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule.getDefaultInstance()) return this; + if (other.hasName()) { + mergeName(other.getName()); + } + if (!other.file_.isEmpty()) { + if (file_.isEmpty()) { + file_ = other.file_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureFileIsMutable(); + file_.addAll(other.file_); + } + + } + if (other.hasSymbolTable()) { + mergeSymbolTable(other.getSymbolTable()); + } + if (other.hasTypeTable()) { + mergeTypeTable(other.getTypeTable()); + } + if (other.hasStringTable()) { + mergeStringTable(other.getStringTable()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!hasSymbolTable()) { + + return false; + } + if (!hasTypeTable()) { + + return false; + } + if (!hasStringTable()) { + + return false; + } + if (!getName().isInitialized()) { + + return false; + } + for (int i = 0; i < getFileCount(); i++) { + if (!getFile(i).isInitialized()) { + + return false; + } + } + if (!getSymbolTable().isInitialized()) { + + return false; + } + if (!getTypeTable().isInitialized()) { + + 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.KotlinIr.IrModule parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrModule) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private java.util.List file_ = + java.util.Collections.emptyList(); + private void ensureFileIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + file_ = new java.util.ArrayList(file_); + bitField0_ |= 0x00000002; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public java.util.List getFileList() { + return java.util.Collections.unmodifiableList(file_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public int getFileCount() { + return file_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile getFile(int index) { + return file_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public Builder setFile( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFileIsMutable(); + file_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public Builder setFile( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile.Builder builderForValue) { + ensureFileIsMutable(); + file_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public Builder addFile(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFileIsMutable(); + file_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public Builder addFile( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFileIsMutable(); + file_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public Builder addFile( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile.Builder builderForValue) { + ensureFileIsMutable(); + file_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public Builder addFile( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFile.Builder builderForValue) { + ensureFileIsMutable(); + file_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public Builder addAllFile( + java.lang.Iterable values) { + ensureFileIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, file_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public Builder clearFile() { + file_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrFile file = 2; + */ + public Builder removeFile(int index) { + ensureFileIsMutable(); + file_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable symbolTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + public boolean hasSymbolTable() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable getSymbolTable() { + return symbolTable_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + public Builder setSymbolTable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable value) { + if (value == null) { + throw new NullPointerException(); + } + symbolTable_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + public Builder setSymbolTable( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.Builder builderForValue) { + symbolTable_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + public Builder mergeSymbolTable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + symbolTable_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.getDefaultInstance()) { + symbolTable_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.newBuilder(symbolTable_).mergeFrom(value).buildPartial(); + } else { + symbolTable_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable symbol_table = 3; + */ + public Builder clearSymbolTable() { + symbolTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable typeTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + public boolean hasTypeTable() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable getTypeTable() { + return typeTable_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + public Builder setTypeTable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable value) { + if (value == null) { + throw new NullPointerException(); + } + typeTable_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + public Builder setTypeTable( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.Builder builderForValue) { + typeTable_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + public Builder mergeTypeTable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + typeTable_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.getDefaultInstance()) { + typeTable_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.newBuilder(typeTable_).mergeFrom(value).buildPartial(); + } else { + typeTable_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeTable type_table = 4; + */ + public Builder clearTypeTable() { + typeTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable stringTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + public boolean hasStringTable() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable getStringTable() { + return stringTable_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + public Builder setStringTable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable value) { + if (value == null) { + throw new NullPointerException(); + } + stringTable_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + public Builder setStringTable( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.Builder builderForValue) { + stringTable_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + public Builder mergeStringTable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + stringTable_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.getDefaultInstance()) { + stringTable_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.newBuilder(stringTable_).mergeFrom(value).buildPartial(); + } else { + stringTable_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.StringTable string_table = 5; + */ + public Builder clearStringTable() { + stringTable_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrModule) + } + + static { + defaultInstance = new IrModule(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrModule) + } + + public interface StringOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.String) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 index = 1; + */ + boolean hasIndex(); + /** + * required int32 index = 1; + */ + int getIndex(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.String} + */ + public static final class String extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.String) + StringOrBuilder { + // Use String.newBuilder() to construct. + private String(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private String(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final String defaultInstance; + public static String getDefaultInstance() { + return defaultInstance; + } + + public String getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private String( + 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); + 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; + index_ = 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 String parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new String(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int INDEX_FIELD_NUMBER = 1; + private int index_; + /** + * required int32 index = 1; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 index = 1; + */ + public int getIndex() { + return index_; + } + + private void initFields() { + index_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasIndex()) { + 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, index_); + } + 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, index_); + } + 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.KotlinIr.String 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.KotlinIr.String 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.KotlinIr.String parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String 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.KotlinIr.String parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String 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.KotlinIr.String parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String 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.KotlinIr.String parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String 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.KotlinIr.String prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.String} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.String) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + index_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.index_ = index_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) return this; + if (other.hasIndex()) { + setIndex(other.getIndex()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasIndex()) { + + 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.KotlinIr.String parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int index_ ; + /** + * required int32 index = 1; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 index = 1; + */ + public int getIndex() { + return index_; + } + /** + * required int32 index = 1; + */ + public Builder setIndex(int value) { + bitField0_ |= 0x00000001; + index_ = value; + + return this; + } + /** + * required int32 index = 1; + */ + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000001); + index_ = 0; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.String) + } + + static { + defaultInstance = new String(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.String) + } + + public interface StringTableOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.StringTable) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated string strings = 1; + */ + org.jetbrains.kotlin.protobuf.ProtocolStringList + getStringsList(); + /** + * repeated string strings = 1; + */ + int getStringsCount(); + /** + * repeated string strings = 1; + */ + java.lang.String getStrings(int index); + /** + * repeated string strings = 1; + */ + org.jetbrains.kotlin.protobuf.ByteString + getStringsBytes(int index); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.StringTable} + */ + public static final class StringTable extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.StringTable) + StringTableOrBuilder { + // Use StringTable.newBuilder() to construct. + private StringTable(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private StringTable(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final StringTable defaultInstance; + public static StringTable getDefaultInstance() { + return defaultInstance; + } + + public StringTable getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private StringTable( + 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); + 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 10: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + strings_ = new org.jetbrains.kotlin.protobuf.LazyStringArrayList(); + mutable_bitField0_ |= 0x00000001; + } + strings_.add(bs); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + strings_ = strings_.getUnmodifiableView(); + } + 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 StringTable parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new StringTable(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int STRINGS_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.protobuf.LazyStringList strings_; + /** + * repeated string strings = 1; + */ + public org.jetbrains.kotlin.protobuf.ProtocolStringList + getStringsList() { + return strings_; + } + /** + * repeated string strings = 1; + */ + public int getStringsCount() { + return strings_.size(); + } + /** + * repeated string strings = 1; + */ + public java.lang.String getStrings(int index) { + return strings_.get(index); + } + /** + * repeated string strings = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getStringsBytes(int index) { + return strings_.getByteString(index); + } + + private void initFields() { + strings_ = org.jetbrains.kotlin.protobuf.LazyStringArrayList.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < strings_.size(); i++) { + output.writeBytes(1, strings_.getByteString(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < strings_.size(); i++) { + dataSize += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBytesSizeNoTag(strings_.getByteString(i)); + } + size += dataSize; + size += 1 * getStringsList().size(); + } + 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.KotlinIr.StringTable 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.KotlinIr.StringTable 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.KotlinIr.StringTable parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable 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.KotlinIr.StringTable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable 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.KotlinIr.StringTable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable 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.KotlinIr.StringTable parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable 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.KotlinIr.StringTable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.StringTable} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.StringTable) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTableOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + strings_ = org.jetbrains.kotlin.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + strings_ = strings_.getUnmodifiableView(); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.strings_ = strings_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable.getDefaultInstance()) return this; + if (!other.strings_.isEmpty()) { + if (strings_.isEmpty()) { + strings_ = other.strings_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureStringsIsMutable(); + strings_.addAll(other.strings_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + 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.KotlinIr.StringTable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.StringTable) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.protobuf.LazyStringList strings_ = org.jetbrains.kotlin.protobuf.LazyStringArrayList.EMPTY; + private void ensureStringsIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + strings_ = new org.jetbrains.kotlin.protobuf.LazyStringArrayList(strings_); + bitField0_ |= 0x00000001; + } + } + /** + * repeated string strings = 1; + */ + public org.jetbrains.kotlin.protobuf.ProtocolStringList + getStringsList() { + return strings_.getUnmodifiableView(); + } + /** + * repeated string strings = 1; + */ + public int getStringsCount() { + return strings_.size(); + } + /** + * repeated string strings = 1; + */ + public java.lang.String getStrings(int index) { + return strings_.get(index); + } + /** + * repeated string strings = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getStringsBytes(int index) { + return strings_.getByteString(index); + } + /** + * repeated string strings = 1; + */ + public Builder setStrings( + int index, java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStringsIsMutable(); + strings_.set(index, value); + + return this; + } + /** + * repeated string strings = 1; + */ + public Builder addStrings( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStringsIsMutable(); + strings_.add(value); + + return this; + } + /** + * repeated string strings = 1; + */ + public Builder addAllStrings( + java.lang.Iterable values) { + ensureStringsIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, strings_); + + return this; + } + /** + * repeated string strings = 1; + */ + public Builder clearStrings() { + strings_ = org.jetbrains.kotlin.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated string strings = 1; + */ + public Builder addStringsBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStringsIsMutable(); + strings_.add(value); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.StringTable) + } + + static { + defaultInstance = new StringTable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.StringTable) + } + + public interface IrSymbolDataOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrSymbolData) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind kind = 1; + */ + boolean hasKind(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind kind = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind getKind(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + boolean hasUniqId(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getUniqId(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + boolean hasTopLevelUniqId(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getTopLevelUniqId(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + boolean hasFqname(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getFqname(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + boolean hasDescriptorReference(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDescriptorReference(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSymbolData} + */ + public static final class IrSymbolData extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrSymbolData) + IrSymbolDataOrBuilder { + // Use IrSymbolData.newBuilder() to construct. + private IrSymbolData(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrSymbolData(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrSymbolData defaultInstance; + public static IrSymbolData getDefaultInstance() { + return defaultInstance; + } + + public IrSymbolData getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrSymbolData( + 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); + 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: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + kind_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = uniqId_.toBuilder(); + } + uniqId_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(uniqId_); + uniqId_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = topLevelUniqId_.toBuilder(); + } + topLevelUniqId_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(topLevelUniqId_); + topLevelUniqId_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = fqname_.toBuilder(); + } + fqname_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(fqname_); + fqname_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = descriptorReference_.toBuilder(); + } + descriptorReference_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(descriptorReference_); + descriptorReference_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + 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 IrSymbolData parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrSymbolData(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int KIND_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind kind_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind kind = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind getKind() { + return kind_; + } + + public static final int UNIQ_ID_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId uniqId_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + public boolean hasUniqId() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getUniqId() { + return uniqId_; + } + + public static final int TOP_LEVEL_UNIQ_ID_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId topLevelUniqId_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + public boolean hasTopLevelUniqId() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getTopLevelUniqId() { + return topLevelUniqId_; + } + + public static final int FQNAME_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String fqname_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + public boolean hasFqname() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getFqname() { + return fqname_; + } + + public static final int DESCRIPTOR_REFERENCE_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference descriptorReference_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + public boolean hasDescriptorReference() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDescriptorReference() { + return descriptorReference_; + } + + private void initFields() { + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind.FUNCTION_SYMBOL; + uniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + topLevelUniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + fqname_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasKind()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasUniqId()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasTopLevelUniqId()) { + memoizedIsInitialized = 0; + return false; + } + if (!getUniqId().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getTopLevelUniqId().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasFqname()) { + if (!getFqname().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDescriptorReference()) { + if (!getDescriptorReference().isInitialized()) { + 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.writeEnum(1, kind_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, uniqId_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, topLevelUniqId_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, fqname_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(5, descriptorReference_); + } + 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 + .computeEnumSize(1, kind_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, uniqId_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, topLevelUniqId_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, fqname_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, descriptorReference_); + } + 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.KotlinIr.IrSymbolData 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.KotlinIr.IrSymbolData 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.KotlinIr.IrSymbolData parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData 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.KotlinIr.IrSymbolData parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData 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.KotlinIr.IrSymbolData parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData 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.KotlinIr.IrSymbolData parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData 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.KotlinIr.IrSymbolData prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSymbolData} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrSymbolData) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolDataOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind.FUNCTION_SYMBOL; + bitField0_ = (bitField0_ & ~0x00000001); + uniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + topLevelUniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + fqname_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.kind_ = kind_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.uniqId_ = uniqId_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.topLevelUniqId_ = topLevelUniqId_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.fqname_ = fqname_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.descriptorReference_ = descriptorReference_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData.getDefaultInstance()) return this; + if (other.hasKind()) { + setKind(other.getKind()); + } + if (other.hasUniqId()) { + mergeUniqId(other.getUniqId()); + } + if (other.hasTopLevelUniqId()) { + mergeTopLevelUniqId(other.getTopLevelUniqId()); + } + if (other.hasFqname()) { + mergeFqname(other.getFqname()); + } + if (other.hasDescriptorReference()) { + mergeDescriptorReference(other.getDescriptorReference()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasKind()) { + + return false; + } + if (!hasUniqId()) { + + return false; + } + if (!hasTopLevelUniqId()) { + + return false; + } + if (!getUniqId().isInitialized()) { + + return false; + } + if (!getTopLevelUniqId().isInitialized()) { + + return false; + } + if (hasFqname()) { + if (!getFqname().isInitialized()) { + + return false; + } + } + if (hasDescriptorReference()) { + if (!getDescriptorReference().isInitialized()) { + + 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.KotlinIr.IrSymbolData parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind.FUNCTION_SYMBOL; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind kind = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind getKind() { + return kind_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind kind = 1; + */ + public Builder setKind(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + kind_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbolKind kind = 1; + */ + public Builder clearKind() { + bitField0_ = (bitField0_ & ~0x00000001); + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolKind.FUNCTION_SYMBOL; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId uniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + public boolean hasUniqId() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getUniqId() { + return uniqId_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + public Builder setUniqId(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + uniqId_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + public Builder setUniqId( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.Builder builderForValue) { + uniqId_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + public Builder mergeUniqId(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + uniqId_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance()) { + uniqId_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.newBuilder(uniqId_).mergeFrom(value).buildPartial(); + } else { + uniqId_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId uniq_id = 2; + */ + public Builder clearUniqId() { + uniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId topLevelUniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + public boolean hasTopLevelUniqId() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId getTopLevelUniqId() { + return topLevelUniqId_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + public Builder setTopLevelUniqId(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + topLevelUniqId_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + public Builder setTopLevelUniqId( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.Builder builderForValue) { + topLevelUniqId_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + public Builder mergeTopLevelUniqId(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + topLevelUniqId_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance()) { + topLevelUniqId_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.newBuilder(topLevelUniqId_).mergeFrom(value).buildPartial(); + } else { + topLevelUniqId_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.UniqId top_level_uniq_id = 3; + */ + public Builder clearTopLevelUniqId() { + topLevelUniqId_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.UniqId.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String fqname_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + public boolean hasFqname() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getFqname() { + return fqname_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + public Builder setFqname(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + fqname_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + public Builder setFqname( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + fqname_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + public Builder mergeFqname(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + fqname_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + fqname_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(fqname_).mergeFrom(value).buildPartial(); + } else { + fqname_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String fqname = 4; + */ + public Builder clearFqname() { + fqname_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + public boolean hasDescriptorReference() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDescriptorReference() { + return descriptorReference_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + public Builder setDescriptorReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference value) { + if (value == null) { + throw new NullPointerException(); + } + descriptorReference_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + public Builder setDescriptorReference( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.Builder builderForValue) { + descriptorReference_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + public Builder mergeDescriptorReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + descriptorReference_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance()) { + descriptorReference_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.newBuilder(descriptorReference_).mergeFrom(value).buildPartial(); + } else { + descriptorReference_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 5; + */ + public Builder clearDescriptorReference() { + descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSymbolData) + } + + static { + defaultInstance = new IrSymbolData(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrSymbolData) + } + + public interface IrSymbolOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrSymbol) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 index = 1; + */ + boolean hasIndex(); + /** + * required int32 index = 1; + */ + int getIndex(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSymbol} + */ + public static final class IrSymbol extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrSymbol) + IrSymbolOrBuilder { + // Use IrSymbol.newBuilder() to construct. + private IrSymbol(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrSymbol(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrSymbol defaultInstance; + public static IrSymbol getDefaultInstance() { + return defaultInstance; + } + + public IrSymbol getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrSymbol( + 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); + 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; + index_ = 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 IrSymbol parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrSymbol(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int INDEX_FIELD_NUMBER = 1; + private int index_; + /** + * required int32 index = 1; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 index = 1; + */ + public int getIndex() { + return index_; + } + + private void initFields() { + index_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasIndex()) { + 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, index_); + } + 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, index_); + } + 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.KotlinIr.IrSymbol 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.KotlinIr.IrSymbol 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.KotlinIr.IrSymbol parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol 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.KotlinIr.IrSymbol parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol 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.KotlinIr.IrSymbol parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol 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.KotlinIr.IrSymbol parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol 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.KotlinIr.IrSymbol prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSymbol} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrSymbol) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + index_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.index_ = index_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) return this; + if (other.hasIndex()) { + setIndex(other.getIndex()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasIndex()) { + + 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.KotlinIr.IrSymbol parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int index_ ; + /** + * required int32 index = 1; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 index = 1; + */ + public int getIndex() { + return index_; + } + /** + * required int32 index = 1; + */ + public Builder setIndex(int value) { + bitField0_ |= 0x00000001; + index_ = value; + + return this; + } + /** + * required int32 index = 1; + */ + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000001); + index_ = 0; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSymbol) + } + + static { + defaultInstance = new IrSymbol(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrSymbol) + } + + public interface IrSymbolTableOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + java.util.List + getSymbolsList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData getSymbols(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + int getSymbolsCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable} + */ + public static final class IrSymbolTable extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable) + IrSymbolTableOrBuilder { + // Use IrSymbolTable.newBuilder() to construct. + private IrSymbolTable(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrSymbolTable(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrSymbolTable defaultInstance; + public static IrSymbolTable getDefaultInstance() { + return defaultInstance; + } + + public IrSymbolTable getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrSymbolTable( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + symbols_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + symbols_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + symbols_ = java.util.Collections.unmodifiableList(symbols_); + } + 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 IrSymbolTable parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrSymbolTable(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int SYMBOLS_FIELD_NUMBER = 1; + private java.util.List symbols_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public java.util.List getSymbolsList() { + return symbols_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public java.util.List + getSymbolsOrBuilderList() { + return symbols_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public int getSymbolsCount() { + return symbols_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData getSymbols(int index) { + return symbols_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolDataOrBuilder getSymbolsOrBuilder( + int index) { + return symbols_.get(index); + } + + private void initFields() { + symbols_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getSymbolsCount(); i++) { + if (!getSymbols(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < symbols_.size(); i++) { + output.writeMessage(1, symbols_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < symbols_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, symbols_.get(i)); + } + 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.KotlinIr.IrSymbolTable 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.KotlinIr.IrSymbolTable 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.KotlinIr.IrSymbolTable parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable 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.KotlinIr.IrSymbolTable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable 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.KotlinIr.IrSymbolTable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable 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.KotlinIr.IrSymbolTable parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable 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.KotlinIr.IrSymbolTable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTableOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbols_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + symbols_ = java.util.Collections.unmodifiableList(symbols_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.symbols_ = symbols_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable.getDefaultInstance()) return this; + if (!other.symbols_.isEmpty()) { + if (symbols_.isEmpty()) { + symbols_ = other.symbols_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureSymbolsIsMutable(); + symbols_.addAll(other.symbols_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getSymbolsCount(); i++) { + if (!getSymbols(i).isInitialized()) { + + 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.KotlinIr.IrSymbolTable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolTable) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List symbols_ = + java.util.Collections.emptyList(); + private void ensureSymbolsIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + symbols_ = new java.util.ArrayList(symbols_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public java.util.List getSymbolsList() { + return java.util.Collections.unmodifiableList(symbols_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public int getSymbolsCount() { + return symbols_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData getSymbols(int index) { + return symbols_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public Builder setSymbols( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSymbolsIsMutable(); + symbols_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public Builder setSymbols( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData.Builder builderForValue) { + ensureSymbolsIsMutable(); + symbols_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public Builder addSymbols(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSymbolsIsMutable(); + symbols_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public Builder addSymbols( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSymbolsIsMutable(); + symbols_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public Builder addSymbols( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData.Builder builderForValue) { + ensureSymbolsIsMutable(); + symbols_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public Builder addSymbols( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolData.Builder builderForValue) { + ensureSymbolsIsMutable(); + symbols_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public Builder addAllSymbols( + java.lang.Iterable values) { + ensureSymbolsIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, symbols_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public Builder clearSymbols() { + symbols_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbolData symbols = 1; + */ + public Builder removeSymbols(int index) { + ensureSymbolsIsMutable(); + symbols_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable) + } + + static { + defaultInstance = new IrSymbolTable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrSymbolTable) + } + + public interface AnnotationsOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.Annotations) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + java.util.List + getAnnotationList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall getAnnotation(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + int getAnnotationCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Annotations} + */ + public static final class Annotations extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.Annotations) + AnnotationsOrBuilder { + // Use Annotations.newBuilder() to construct. + private Annotations(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Annotations(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final Annotations defaultInstance; + public static Annotations getDefaultInstance() { + return defaultInstance; + } + + public Annotations getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private Annotations( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + annotation_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + annotation_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + annotation_ = java.util.Collections.unmodifiableList(annotation_); + } + 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 Annotations parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new Annotations(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int ANNOTATION_FIELD_NUMBER = 1; + private java.util.List annotation_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public java.util.List getAnnotationList() { + return annotation_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public java.util.List + getAnnotationOrBuilderList() { + return annotation_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public int getAnnotationCount() { + return annotation_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall getAnnotation(int index) { + return annotation_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCallOrBuilder getAnnotationOrBuilder( + int index) { + return annotation_.get(index); + } + + private void initFields() { + annotation_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getAnnotationCount(); i++) { + if (!getAnnotation(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < annotation_.size(); i++) { + output.writeMessage(1, annotation_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < annotation_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, annotation_.get(i)); + } + 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.KotlinIr.Annotations 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.KotlinIr.Annotations 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.KotlinIr.Annotations parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations 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.KotlinIr.Annotations parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations 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.KotlinIr.Annotations parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations 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.KotlinIr.Annotations parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations 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.KotlinIr.Annotations prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Annotations} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.Annotations) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.AnnotationsOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + annotation_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + annotation_ = java.util.Collections.unmodifiableList(annotation_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.annotation_ = annotation_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance()) return this; + if (!other.annotation_.isEmpty()) { + if (annotation_.isEmpty()) { + annotation_ = other.annotation_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureAnnotationIsMutable(); + annotation_.addAll(other.annotation_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getAnnotationCount(); i++) { + if (!getAnnotation(i).isInitialized()) { + + 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.KotlinIr.Annotations parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List annotation_ = + java.util.Collections.emptyList(); + private void ensureAnnotationIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + annotation_ = new java.util.ArrayList(annotation_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public java.util.List getAnnotationList() { + return java.util.Collections.unmodifiableList(annotation_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public int getAnnotationCount() { + return annotation_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall getAnnotation(int index) { + return annotation_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public Builder setAnnotation( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall value) { + if (value == null) { + throw new NullPointerException(); + } + ensureAnnotationIsMutable(); + annotation_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public Builder setAnnotation( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Builder builderForValue) { + ensureAnnotationIsMutable(); + annotation_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public Builder addAnnotation(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall value) { + if (value == null) { + throw new NullPointerException(); + } + ensureAnnotationIsMutable(); + annotation_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public Builder addAnnotation( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall value) { + if (value == null) { + throw new NullPointerException(); + } + ensureAnnotationIsMutable(); + annotation_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public Builder addAnnotation( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Builder builderForValue) { + ensureAnnotationIsMutable(); + annotation_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public Builder addAnnotation( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Builder builderForValue) { + ensureAnnotationIsMutable(); + annotation_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public Builder addAllAnnotation( + java.lang.Iterable values) { + ensureAnnotationIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, annotation_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public Builder clearAnnotation() { + annotation_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrCall annotation = 1; + */ + public Builder removeAnnotation(int index) { + ensureAnnotationIsMutable(); + annotation_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.Annotations) + } + + static { + defaultInstance = new Annotations(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.Annotations) + } + + public interface TypeArgumentsOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.TypeArguments) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + java.util.List + getTypeArgumentList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getTypeArgument(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + int getTypeArgumentCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.TypeArguments} + */ + public static final class TypeArguments extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.TypeArguments) + TypeArgumentsOrBuilder { + // Use TypeArguments.newBuilder() to construct. + private TypeArguments(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private TypeArguments(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final TypeArguments defaultInstance; + public static TypeArguments getDefaultInstance() { + return defaultInstance; + } + + public TypeArguments getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private TypeArguments( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + typeArgument_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + typeArgument_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + typeArgument_ = java.util.Collections.unmodifiableList(typeArgument_); + } + 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 TypeArguments parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new TypeArguments(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int TYPE_ARGUMENT_FIELD_NUMBER = 1; + private java.util.List typeArgument_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public java.util.List getTypeArgumentList() { + return typeArgument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public java.util.List + getTypeArgumentOrBuilderList() { + return typeArgument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public int getTypeArgumentCount() { + return typeArgument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getTypeArgument(int index) { + return typeArgument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndexOrBuilder getTypeArgumentOrBuilder( + int index) { + return typeArgument_.get(index); + } + + private void initFields() { + typeArgument_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getTypeArgumentCount(); i++) { + if (!getTypeArgument(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < typeArgument_.size(); i++) { + output.writeMessage(1, typeArgument_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < typeArgument_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, typeArgument_.get(i)); + } + 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.KotlinIr.TypeArguments 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.KotlinIr.TypeArguments 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.KotlinIr.TypeArguments parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments 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.KotlinIr.TypeArguments parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments 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.KotlinIr.TypeArguments parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments 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.KotlinIr.TypeArguments parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments 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.KotlinIr.TypeArguments prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.TypeArguments} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.TypeArguments) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArgumentsOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + typeArgument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + typeArgument_ = java.util.Collections.unmodifiableList(typeArgument_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.typeArgument_ = typeArgument_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.getDefaultInstance()) return this; + if (!other.typeArgument_.isEmpty()) { + if (typeArgument_.isEmpty()) { + typeArgument_ = other.typeArgument_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureTypeArgumentIsMutable(); + typeArgument_.addAll(other.typeArgument_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getTypeArgumentCount(); i++) { + if (!getTypeArgument(i).isInitialized()) { + + 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.KotlinIr.TypeArguments parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List typeArgument_ = + java.util.Collections.emptyList(); + private void ensureTypeArgumentIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + typeArgument_ = new java.util.ArrayList(typeArgument_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public java.util.List getTypeArgumentList() { + return java.util.Collections.unmodifiableList(typeArgument_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public int getTypeArgumentCount() { + return typeArgument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getTypeArgument(int index) { + return typeArgument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public Builder setTypeArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeArgumentIsMutable(); + typeArgument_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public Builder setTypeArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + ensureTypeArgumentIsMutable(); + typeArgument_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public Builder addTypeArgument(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeArgumentIsMutable(); + typeArgument_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public Builder addTypeArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeArgumentIsMutable(); + typeArgument_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public Builder addTypeArgument( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + ensureTypeArgumentIsMutable(); + typeArgument_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public Builder addTypeArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + ensureTypeArgumentIsMutable(); + typeArgument_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public Builder addAllTypeArgument( + java.lang.Iterable values) { + ensureTypeArgumentIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, typeArgument_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public Builder clearTypeArgument() { + typeArgument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type_argument = 1; + */ + public Builder removeTypeArgument(int index) { + ensureTypeArgumentIsMutable(); + typeArgument_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.TypeArguments) + } + + static { + defaultInstance = new TypeArguments(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.TypeArguments) + } + + public interface IrStarProjectionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrStarProjection) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional bool void = 1; + */ + boolean hasVoid(); + /** + * optional bool void = 1; + */ + boolean getVoid(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrStarProjection} + */ + public static final class IrStarProjection extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrStarProjection) + IrStarProjectionOrBuilder { + // Use IrStarProjection.newBuilder() to construct. + private IrStarProjection(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrStarProjection(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrStarProjection defaultInstance; + public static IrStarProjection getDefaultInstance() { + return defaultInstance; + } + + public IrStarProjection getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrStarProjection( + 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); + 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; + void_ = input.readBool(); + 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 IrStarProjection parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrStarProjection(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int VOID_FIELD_NUMBER = 1; + private boolean void_; + /** + * optional bool void = 1; + */ + public boolean hasVoid() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional bool void = 1; + */ + public boolean getVoid() { + return void_; + } + + private void initFields() { + void_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 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.writeBool(1, void_); + } + 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 + .computeBoolSize(1, void_); + } + 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.KotlinIr.IrStarProjection 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.KotlinIr.IrStarProjection 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.KotlinIr.IrStarProjection parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection 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.KotlinIr.IrStarProjection parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection 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.KotlinIr.IrStarProjection parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection 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.KotlinIr.IrStarProjection parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection 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.KotlinIr.IrStarProjection prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrStarProjection} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrStarProjection) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjectionOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + void_ = false; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.void_ = void_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.getDefaultInstance()) return this; + if (other.hasVoid()) { + setVoid(other.getVoid()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + 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.KotlinIr.IrStarProjection parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private boolean void_ ; + /** + * optional bool void = 1; + */ + public boolean hasVoid() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional bool void = 1; + */ + public boolean getVoid() { + return void_; + } + /** + * optional bool void = 1; + */ + public Builder setVoid(boolean value) { + bitField0_ |= 0x00000001; + void_ = value; + + return this; + } + /** + * optional bool void = 1; + */ + public Builder clearVoid() { + bitField0_ = (bitField0_ & ~0x00000001); + void_ = false; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrStarProjection) + } + + static { + defaultInstance = new IrStarProjection(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrStarProjection) + } + + public interface IrTypeProjectionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 1; + */ + boolean hasVariance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance getVariance(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection} + */ + public static final class IrTypeProjection extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection) + IrTypeProjectionOrBuilder { + // Use IrTypeProjection.newBuilder() to construct. + private IrTypeProjection(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrTypeProjection(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrTypeProjection defaultInstance; + public static IrTypeProjection getDefaultInstance() { + return defaultInstance; + } + + public IrTypeProjection getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrTypeProjection( + 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); + 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: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + variance_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(type_); + type_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrTypeProjection parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrTypeProjection(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int VARIANCE_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance variance_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 1; + */ + public boolean hasVariance() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance getVariance() { + return variance_; + } + + public static final int TYPE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + + private void initFields() { + variance_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.IN; + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasVariance()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (!getType().isInitialized()) { + 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.writeEnum(1, variance_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, type_); + } + 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 + .computeEnumSize(1, variance_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, type_); + } + 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.KotlinIr.IrTypeProjection 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.KotlinIr.IrTypeProjection 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.KotlinIr.IrTypeProjection parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection 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.KotlinIr.IrTypeProjection parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection 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.KotlinIr.IrTypeProjection parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection 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.KotlinIr.IrTypeProjection parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection 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.KotlinIr.IrTypeProjection prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjectionOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + variance_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.IN; + bitField0_ = (bitField0_ & ~0x00000001); + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.variance_ = variance_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.type_ = type_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.getDefaultInstance()) return this; + if (other.hasVariance()) { + setVariance(other.getVariance()); + } + if (other.hasType()) { + mergeType(other.getType()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasVariance()) { + + return false; + } + if (!hasType()) { + + return false; + } + if (!getType().isInitialized()) { + + 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.KotlinIr.IrTypeProjection parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance variance_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.IN; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 1; + */ + public boolean hasVariance() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance getVariance() { + return variance_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 1; + */ + public Builder setVariance(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + variance_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 1; + */ + public Builder clearVariance() { + bitField0_ = (bitField0_ & ~0x00000001); + variance_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.IN; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public Builder setType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public Builder setType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public Builder mergeType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + type_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection) + } + + static { + defaultInstance = new IrTypeProjection(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection) + } + + public interface IrTypeArgumentOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + boolean hasStar(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection getStar(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + boolean hasType(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection getType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument} + */ + public static final class IrTypeArgument extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument) + IrTypeArgumentOrBuilder { + // Use IrTypeArgument.newBuilder() to construct. + private IrTypeArgument(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrTypeArgument(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrTypeArgument defaultInstance; + public static IrTypeArgument getDefaultInstance() { + return defaultInstance; + } + + public IrTypeArgument getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrTypeArgument( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.Builder subBuilder = null; + if (kindCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection) kind_); + kind_ = subBuilder.buildPartial(); + } + kindCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.Builder subBuilder = null; + if (kindCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection) kind_); + kind_ = subBuilder.buildPartial(); + } + kindCase_ = 2; + 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 IrTypeArgument parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrTypeArgument(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + private int kindCase_ = 0; + private java.lang.Object kind_; + public enum KindCase + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + STAR(1), + TYPE(2), + KIND_NOT_SET(0); + private int value = 0; + private KindCase(int value) { + this.value = value; + } + public static KindCase valueOf(int value) { + switch (value) { + case 1: return STAR; + case 2: return TYPE; + case 0: return KIND_NOT_SET; + default: throw new java.lang.IllegalArgumentException( + "Value is undefined for this oneof enum."); + } + } + public int getNumber() { + return this.value; + } + }; + + public KindCase + getKindCase() { + return KindCase.valueOf( + kindCase_); + } + + public static final int STAR_FIELD_NUMBER = 1; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + public boolean hasStar() { + return kindCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection getStar() { + if (kindCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.getDefaultInstance(); + } + + public static final int TYPE_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + public boolean hasType() { + return kindCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection getType() { + if (kindCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.getDefaultInstance(); + } + + private void initFields() { + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (hasType()) { + if (!getType().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (kindCase_ == 1) { + output.writeMessage(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection) kind_); + } + if (kindCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection) kind_); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (kindCase_ == 1) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection) kind_); + } + if (kindCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection) kind_); + } + 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.KotlinIr.IrTypeArgument 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.KotlinIr.IrTypeArgument 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.KotlinIr.IrTypeArgument parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument 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.KotlinIr.IrTypeArgument parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument 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.KotlinIr.IrTypeArgument parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument 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.KotlinIr.IrTypeArgument parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument 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.KotlinIr.IrTypeArgument prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgumentOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + kindCase_ = 0; + kind_ = null; + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (kindCase_ == 1) { + result.kind_ = kind_; + } + if (kindCase_ == 2) { + result.kind_ = kind_; + } + result.bitField0_ = to_bitField0_; + result.kindCase_ = kindCase_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument.getDefaultInstance()) return this; + switch (other.getKindCase()) { + case STAR: { + mergeStar(other.getStar()); + break; + } + case TYPE: { + mergeType(other.getType()); + break; + } + case KIND_NOT_SET: { + break; + } + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (hasType()) { + if (!getType().isInitialized()) { + + 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.KotlinIr.IrTypeArgument parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int kindCase_ = 0; + private java.lang.Object kind_; + public KindCase + getKindCase() { + return KindCase.valueOf( + kindCase_); + } + + public Builder clearKind() { + kindCase_ = 0; + kind_ = null; + return this; + } + + private int bitField0_; + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + public boolean hasStar() { + return kindCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection getStar() { + if (kindCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + public Builder setStar(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + public Builder setStar( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + public Builder mergeStar(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection value) { + if (kindCase_ == 1 && + kind_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStarProjection) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStarProjection star = 1; + */ + public Builder clearStar() { + if (kindCase_ == 1) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + public boolean hasType() { + return kindCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection getType() { + if (kindCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + public Builder setType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + public Builder setType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + public Builder mergeType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection value) { + if (kindCase_ == 2 && + kind_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeProjection) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeProjection type = 2; + */ + public Builder clearType() { + if (kindCase_ == 2) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument) + } + + static { + defaultInstance = new IrTypeArgument(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument) + } + + public interface IrSimpleTypeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrSimpleType) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + boolean hasAnnotations(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + boolean hasClassifier(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getClassifier(); + + /** + * required bool has_question_mark = 3; + */ + boolean hasHasQuestionMark(); + /** + * required bool has_question_mark = 3; + */ + boolean getHasQuestionMark(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + java.util.List + getArgumentList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument getArgument(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + int getArgumentCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSimpleType} + */ + public static final class IrSimpleType extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrSimpleType) + IrSimpleTypeOrBuilder { + // Use IrSimpleType.newBuilder() to construct. + private IrSimpleType(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrSimpleType(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrSimpleType defaultInstance; + public static IrSimpleType getDefaultInstance() { + return defaultInstance; + } + + public IrSimpleType getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrSimpleType( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = annotations_.toBuilder(); + } + annotations_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(annotations_); + annotations_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = classifier_.toBuilder(); + } + classifier_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(classifier_); + classifier_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 24: { + bitField0_ |= 0x00000004; + hasQuestionMark_ = input.readBool(); + break; + } + case 34: { + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + argument_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000008; + } + argument_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + argument_ = java.util.Collections.unmodifiableList(argument_); + } + 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 IrSimpleType parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrSimpleType(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int ANNOTATIONS_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + + public static final int CLASSIFIER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol classifier_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + public boolean hasClassifier() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getClassifier() { + return classifier_; + } + + public static final int HAS_QUESTION_MARK_FIELD_NUMBER = 3; + private boolean hasQuestionMark_; + /** + * required bool has_question_mark = 3; + */ + public boolean hasHasQuestionMark() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required bool has_question_mark = 3; + */ + public boolean getHasQuestionMark() { + return hasQuestionMark_; + } + + public static final int ARGUMENT_FIELD_NUMBER = 4; + private java.util.List argument_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public java.util.List getArgumentList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public java.util.List + getArgumentOrBuilderList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgumentOrBuilder getArgumentOrBuilder( + int index) { + return argument_.get(index); + } + + private void initFields() { + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + classifier_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + hasQuestionMark_ = false; + argument_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasAnnotations()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasClassifier()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasHasQuestionMark()) { + memoizedIsInitialized = 0; + return false; + } + if (!getAnnotations().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getClassifier().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getArgumentCount(); i++) { + if (!getArgument(i).isInitialized()) { + 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.writeMessage(1, annotations_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, classifier_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBool(3, hasQuestionMark_); + } + for (int i = 0; i < argument_.size(); i++) { + output.writeMessage(4, argument_.get(i)); + } + 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 + .computeMessageSize(1, annotations_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, classifier_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(3, hasQuestionMark_); + } + for (int i = 0; i < argument_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, argument_.get(i)); + } + 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.KotlinIr.IrSimpleType 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.KotlinIr.IrSimpleType 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.KotlinIr.IrSimpleType parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType 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.KotlinIr.IrSimpleType parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType 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.KotlinIr.IrSimpleType parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType 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.KotlinIr.IrSimpleType parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType 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.KotlinIr.IrSimpleType prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSimpleType} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrSimpleType) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleTypeOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + classifier_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + hasQuestionMark_ = false; + bitField0_ = (bitField0_ & ~0x00000004); + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.annotations_ = annotations_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.classifier_ = classifier_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.hasQuestionMark_ = hasQuestionMark_; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + argument_ = java.util.Collections.unmodifiableList(argument_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.argument_ = argument_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.getDefaultInstance()) return this; + if (other.hasAnnotations()) { + mergeAnnotations(other.getAnnotations()); + } + if (other.hasClassifier()) { + mergeClassifier(other.getClassifier()); + } + if (other.hasHasQuestionMark()) { + setHasQuestionMark(other.getHasQuestionMark()); + } + if (!other.argument_.isEmpty()) { + if (argument_.isEmpty()) { + argument_ = other.argument_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureArgumentIsMutable(); + argument_.addAll(other.argument_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasAnnotations()) { + + return false; + } + if (!hasClassifier()) { + + return false; + } + if (!hasHasQuestionMark()) { + + return false; + } + if (!getAnnotations().isInitialized()) { + + return false; + } + if (!getClassifier().isInitialized()) { + + return false; + } + for (int i = 0; i < getArgumentCount(); i++) { + if (!getArgument(i).isInitialized()) { + + 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.KotlinIr.IrSimpleType parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder setAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (value == null) { + throw new NullPointerException(); + } + annotations_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder setAnnotations( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder builderForValue) { + annotations_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder mergeAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + annotations_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance()) { + annotations_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.newBuilder(annotations_).mergeFrom(value).buildPartial(); + } else { + annotations_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder clearAnnotations() { + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol classifier_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + public boolean hasClassifier() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getClassifier() { + return classifier_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + public Builder setClassifier(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + classifier_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + public Builder setClassifier( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + classifier_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + public Builder mergeClassifier(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + classifier_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + classifier_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(classifier_).mergeFrom(value).buildPartial(); + } else { + classifier_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol classifier = 2; + */ + public Builder clearClassifier() { + classifier_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private boolean hasQuestionMark_ ; + /** + * required bool has_question_mark = 3; + */ + public boolean hasHasQuestionMark() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required bool has_question_mark = 3; + */ + public boolean getHasQuestionMark() { + return hasQuestionMark_; + } + /** + * required bool has_question_mark = 3; + */ + public Builder setHasQuestionMark(boolean value) { + bitField0_ |= 0x00000004; + hasQuestionMark_ = value; + + return this; + } + /** + * required bool has_question_mark = 3; + */ + public Builder clearHasQuestionMark() { + bitField0_ = (bitField0_ & ~0x00000004); + hasQuestionMark_ = false; + + return this; + } + + private java.util.List argument_ = + java.util.Collections.emptyList(); + private void ensureArgumentIsMutable() { + if (!((bitField0_ & 0x00000008) == 0x00000008)) { + argument_ = new java.util.ArrayList(argument_); + bitField0_ |= 0x00000008; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public java.util.List getArgumentList() { + return java.util.Collections.unmodifiableList(argument_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public Builder addArgument(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public Builder addArgument( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeArgument.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public Builder addAllArgument( + java.lang.Iterable values) { + ensureArgumentIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, argument_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public Builder clearArgument() { + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeArgument argument = 4; + */ + public Builder removeArgument(int index) { + ensureArgumentIsMutable(); + argument_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSimpleType) + } + + static { + defaultInstance = new IrSimpleType(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrSimpleType) + } + + public interface IrDynamicTypeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrDynamicType) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + boolean hasAnnotations(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDynamicType} + */ + public static final class IrDynamicType extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrDynamicType) + IrDynamicTypeOrBuilder { + // Use IrDynamicType.newBuilder() to construct. + private IrDynamicType(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDynamicType(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDynamicType defaultInstance; + public static IrDynamicType getDefaultInstance() { + return defaultInstance; + } + + public IrDynamicType getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDynamicType( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = annotations_.toBuilder(); + } + annotations_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(annotations_); + annotations_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrDynamicType parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDynamicType(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int ANNOTATIONS_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + + private void initFields() { + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasAnnotations()) { + memoizedIsInitialized = 0; + return false; + } + if (!getAnnotations().isInitialized()) { + 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.writeMessage(1, annotations_); + } + 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 + .computeMessageSize(1, annotations_); + } + 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.KotlinIr.IrDynamicType 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.KotlinIr.IrDynamicType 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.KotlinIr.IrDynamicType parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType 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.KotlinIr.IrDynamicType parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType 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.KotlinIr.IrDynamicType parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType 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.KotlinIr.IrDynamicType parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType 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.KotlinIr.IrDynamicType prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDynamicType} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrDynamicType) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicTypeOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.annotations_ = annotations_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.getDefaultInstance()) return this; + if (other.hasAnnotations()) { + mergeAnnotations(other.getAnnotations()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasAnnotations()) { + + return false; + } + if (!getAnnotations().isInitialized()) { + + 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.KotlinIr.IrDynamicType parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder setAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (value == null) { + throw new NullPointerException(); + } + annotations_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder setAnnotations( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder builderForValue) { + annotations_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder mergeAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + annotations_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance()) { + annotations_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.newBuilder(annotations_).mergeFrom(value).buildPartial(); + } else { + annotations_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder clearAnnotations() { + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrDynamicType) + } + + static { + defaultInstance = new IrDynamicType(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrDynamicType) + } + + public interface IrErrorTypeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrErrorType) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + boolean hasAnnotations(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrErrorType} + */ + public static final class IrErrorType extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrErrorType) + IrErrorTypeOrBuilder { + // Use IrErrorType.newBuilder() to construct. + private IrErrorType(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrErrorType(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrErrorType defaultInstance; + public static IrErrorType getDefaultInstance() { + return defaultInstance; + } + + public IrErrorType getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrErrorType( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = annotations_.toBuilder(); + } + annotations_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(annotations_); + annotations_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrErrorType parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrErrorType(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int ANNOTATIONS_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + + private void initFields() { + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasAnnotations()) { + memoizedIsInitialized = 0; + return false; + } + if (!getAnnotations().isInitialized()) { + 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.writeMessage(1, annotations_); + } + 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 + .computeMessageSize(1, annotations_); + } + 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.KotlinIr.IrErrorType 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.KotlinIr.IrErrorType 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.KotlinIr.IrErrorType parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType 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.KotlinIr.IrErrorType parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType 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.KotlinIr.IrErrorType parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType 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.KotlinIr.IrErrorType parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType 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.KotlinIr.IrErrorType prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrErrorType} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrErrorType) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorTypeOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.annotations_ = annotations_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.getDefaultInstance()) return this; + if (other.hasAnnotations()) { + mergeAnnotations(other.getAnnotations()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasAnnotations()) { + + return false; + } + if (!getAnnotations().isInitialized()) { + + 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.KotlinIr.IrErrorType parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder setAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (value == null) { + throw new NullPointerException(); + } + annotations_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder setAnnotations( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder builderForValue) { + annotations_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder mergeAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + annotations_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance()) { + annotations_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.newBuilder(annotations_).mergeFrom(value).buildPartial(); + } else { + annotations_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 1; + */ + public Builder clearAnnotations() { + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrErrorType) + } + + static { + defaultInstance = new IrErrorType(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrErrorType) + } + + public interface IrTypeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrType) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + boolean hasSimple(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType getSimple(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + boolean hasDynamic(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType getDynamic(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + boolean hasError(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType getError(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrType} + */ + public static final class IrType extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrType) + IrTypeOrBuilder { + // Use IrType.newBuilder() to construct. + private IrType(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrType(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrType defaultInstance; + public static IrType getDefaultInstance() { + return defaultInstance; + } + + public IrType getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrType( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.Builder subBuilder = null; + if (kindCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType) kind_); + kind_ = subBuilder.buildPartial(); + } + kindCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.Builder subBuilder = null; + if (kindCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType) kind_); + kind_ = subBuilder.buildPartial(); + } + kindCase_ = 2; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.Builder subBuilder = null; + if (kindCase_ == 3) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType) kind_); + kind_ = subBuilder.buildPartial(); + } + kindCase_ = 3; + 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 IrType parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrType(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + private int kindCase_ = 0; + private java.lang.Object kind_; + public enum KindCase + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + SIMPLE(1), + DYNAMIC(2), + ERROR(3), + KIND_NOT_SET(0); + private int value = 0; + private KindCase(int value) { + this.value = value; + } + public static KindCase valueOf(int value) { + switch (value) { + case 1: return SIMPLE; + case 2: return DYNAMIC; + case 3: return ERROR; + case 0: return KIND_NOT_SET; + default: throw new java.lang.IllegalArgumentException( + "Value is undefined for this oneof enum."); + } + } + public int getNumber() { + return this.value; + } + }; + + public KindCase + getKindCase() { + return KindCase.valueOf( + kindCase_); + } + + public static final int SIMPLE_FIELD_NUMBER = 1; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + public boolean hasSimple() { + return kindCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType getSimple() { + if (kindCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.getDefaultInstance(); + } + + public static final int DYNAMIC_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + public boolean hasDynamic() { + return kindCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType getDynamic() { + if (kindCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.getDefaultInstance(); + } + + public static final int ERROR_FIELD_NUMBER = 3; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + public boolean hasError() { + return kindCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType getError() { + if (kindCase_ == 3) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.getDefaultInstance(); + } + + private void initFields() { + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (hasSimple()) { + if (!getSimple().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDynamic()) { + if (!getDynamic().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasError()) { + if (!getError().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (kindCase_ == 1) { + output.writeMessage(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType) kind_); + } + if (kindCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType) kind_); + } + if (kindCase_ == 3) { + output.writeMessage(3, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType) kind_); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (kindCase_ == 1) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType) kind_); + } + if (kindCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType) kind_); + } + if (kindCase_ == 3) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType) kind_); + } + 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.KotlinIr.IrType 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.KotlinIr.IrType 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.KotlinIr.IrType parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType 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.KotlinIr.IrType parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType 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.KotlinIr.IrType parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType 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.KotlinIr.IrType parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType 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.KotlinIr.IrType prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrType} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrType) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + kindCase_ = 0; + kind_ = null; + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (kindCase_ == 1) { + result.kind_ = kind_; + } + if (kindCase_ == 2) { + result.kind_ = kind_; + } + if (kindCase_ == 3) { + result.kind_ = kind_; + } + result.bitField0_ = to_bitField0_; + result.kindCase_ = kindCase_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType.getDefaultInstance()) return this; + switch (other.getKindCase()) { + case SIMPLE: { + mergeSimple(other.getSimple()); + break; + } + case DYNAMIC: { + mergeDynamic(other.getDynamic()); + break; + } + case ERROR: { + mergeError(other.getError()); + break; + } + case KIND_NOT_SET: { + break; + } + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (hasSimple()) { + if (!getSimple().isInitialized()) { + + return false; + } + } + if (hasDynamic()) { + if (!getDynamic().isInitialized()) { + + return false; + } + } + if (hasError()) { + if (!getError().isInitialized()) { + + 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.KotlinIr.IrType parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int kindCase_ = 0; + private java.lang.Object kind_; + public KindCase + getKindCase() { + return KindCase.valueOf( + kindCase_); + } + + public Builder clearKind() { + kindCase_ = 0; + kind_ = null; + return this; + } + + private int bitField0_; + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + public boolean hasSimple() { + return kindCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType getSimple() { + if (kindCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + public Builder setSimple(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + public Builder setSimple( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + public Builder mergeSimple(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType value) { + if (kindCase_ == 1 && + kind_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSimpleType) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSimpleType simple = 1; + */ + public Builder clearSimple() { + if (kindCase_ == 1) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + public boolean hasDynamic() { + return kindCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType getDynamic() { + if (kindCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + public Builder setDynamic(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + public Builder setDynamic( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + public Builder mergeDynamic(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType value) { + if (kindCase_ == 2 && + kind_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicType) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicType dynamic = 2; + */ + public Builder clearDynamic() { + if (kindCase_ == 2) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + public boolean hasError() { + return kindCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType getError() { + if (kindCase_ == 3) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType) kind_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + public Builder setError(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + public Builder setError( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + public Builder mergeError(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType value) { + if (kindCase_ == 3 && + kind_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrErrorType) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrErrorType error = 3; + */ + public Builder clearError() { + if (kindCase_ == 3) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrType) + } + + static { + defaultInstance = new IrType(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrType) + } + + public interface IrTypeTableOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrTypeTable) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + java.util.List + getTypesList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType getTypes(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + int getTypesCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeTable} + */ + public static final class IrTypeTable extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeTable) + IrTypeTableOrBuilder { + // Use IrTypeTable.newBuilder() to construct. + private IrTypeTable(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrTypeTable(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrTypeTable defaultInstance; + public static IrTypeTable getDefaultInstance() { + return defaultInstance; + } + + public IrTypeTable getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrTypeTable( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + types_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + types_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + types_ = java.util.Collections.unmodifiableList(types_); + } + 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 IrTypeTable parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrTypeTable(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int TYPES_FIELD_NUMBER = 1; + private java.util.List types_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public java.util.List getTypesList() { + return types_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public java.util.List + getTypesOrBuilderList() { + return types_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public int getTypesCount() { + return types_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType getTypes(int index) { + return types_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOrBuilder getTypesOrBuilder( + int index) { + return types_.get(index); + } + + private void initFields() { + types_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getTypesCount(); i++) { + if (!getTypes(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < types_.size(); i++) { + output.writeMessage(1, types_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < types_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, types_.get(i)); + } + 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.KotlinIr.IrTypeTable 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.KotlinIr.IrTypeTable 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.KotlinIr.IrTypeTable parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable 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.KotlinIr.IrTypeTable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable 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.KotlinIr.IrTypeTable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable 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.KotlinIr.IrTypeTable parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable 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.KotlinIr.IrTypeTable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeTable} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeTable) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTableOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + types_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + types_ = java.util.Collections.unmodifiableList(types_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.types_ = types_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable.getDefaultInstance()) return this; + if (!other.types_.isEmpty()) { + if (types_.isEmpty()) { + types_ = other.types_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureTypesIsMutable(); + types_.addAll(other.types_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getTypesCount(); i++) { + if (!getTypes(i).isInitialized()) { + + 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.KotlinIr.IrTypeTable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeTable) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List types_ = + java.util.Collections.emptyList(); + private void ensureTypesIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + types_ = new java.util.ArrayList(types_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public java.util.List getTypesList() { + return java.util.Collections.unmodifiableList(types_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public int getTypesCount() { + return types_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType getTypes(int index) { + return types_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public Builder setTypes( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypesIsMutable(); + types_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public Builder setTypes( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType.Builder builderForValue) { + ensureTypesIsMutable(); + types_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public Builder addTypes(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypesIsMutable(); + types_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public Builder addTypes( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypesIsMutable(); + types_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public Builder addTypes( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType.Builder builderForValue) { + ensureTypesIsMutable(); + types_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public Builder addTypes( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrType.Builder builderForValue) { + ensureTypesIsMutable(); + types_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public Builder addAllTypes( + java.lang.Iterable values) { + ensureTypesIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, types_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public Builder clearTypes() { + types_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrType types = 1; + */ + public Builder removeTypes(int index) { + ensureTypesIsMutable(); + types_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeTable) + } + + static { + defaultInstance = new IrTypeTable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeTable) + } + + public interface IrTypeIndexOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 index = 1; + */ + boolean hasIndex(); + /** + * required int32 index = 1; + */ + int getIndex(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex} + */ + public static final class IrTypeIndex extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex) + IrTypeIndexOrBuilder { + // Use IrTypeIndex.newBuilder() to construct. + private IrTypeIndex(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrTypeIndex(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrTypeIndex defaultInstance; + public static IrTypeIndex getDefaultInstance() { + return defaultInstance; + } + + public IrTypeIndex getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrTypeIndex( + 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); + 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; + index_ = 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 IrTypeIndex parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrTypeIndex(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int INDEX_FIELD_NUMBER = 1; + private int index_; + /** + * required int32 index = 1; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 index = 1; + */ + public int getIndex() { + return index_; + } + + private void initFields() { + index_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasIndex()) { + 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, index_); + } + 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, index_); + } + 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.KotlinIr.IrTypeIndex 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.KotlinIr.IrTypeIndex 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.KotlinIr.IrTypeIndex parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex 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.KotlinIr.IrTypeIndex parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex 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.KotlinIr.IrTypeIndex parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex 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.KotlinIr.IrTypeIndex parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex 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.KotlinIr.IrTypeIndex prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndexOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + index_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.index_ = index_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) return this; + if (other.hasIndex()) { + setIndex(other.getIndex()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasIndex()) { + + 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.KotlinIr.IrTypeIndex parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int index_ ; + /** + * required int32 index = 1; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 index = 1; + */ + public int getIndex() { + return index_; + } + /** + * required int32 index = 1; + */ + public Builder setIndex(int value) { + bitField0_ |= 0x00000001; + index_ = value; + + return this; + } + /** + * required int32 index = 1; + */ + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000001); + index_ = 0; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex) + } + + static { + defaultInstance = new IrTypeIndex(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex) + } + + public interface IrBreakOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrBreak) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 loop_id = 1; + */ + boolean hasLoopId(); + /** + * required int32 loop_id = 1; + */ + int getLoopId(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + boolean hasLabel(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getLabel(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrBreak} + */ + public static final class IrBreak extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrBreak) + IrBreakOrBuilder { + // Use IrBreak.newBuilder() to construct. + private IrBreak(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrBreak(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrBreak defaultInstance; + public static IrBreak getDefaultInstance() { + return defaultInstance; + } + + public IrBreak getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrBreak( + 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); + 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; + loopId_ = input.readInt32(); + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = label_.toBuilder(); + } + label_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(label_); + label_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrBreak parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrBreak(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int LOOP_ID_FIELD_NUMBER = 1; + private int loopId_; + /** + * required int32 loop_id = 1; + */ + public boolean hasLoopId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 loop_id = 1; + */ + public int getLoopId() { + return loopId_; + } + + public static final int LABEL_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String label_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getLabel() { + return label_; + } + + private void initFields() { + loopId_ = 0; + label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasLoopId()) { + memoizedIsInitialized = 0; + return false; + } + if (hasLabel()) { + if (!getLabel().isInitialized()) { + 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, loopId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, label_); + } + 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, loopId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, label_); + } + 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.KotlinIr.IrBreak 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.KotlinIr.IrBreak 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.KotlinIr.IrBreak parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak 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.KotlinIr.IrBreak parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak 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.KotlinIr.IrBreak parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak 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.KotlinIr.IrBreak parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak 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.KotlinIr.IrBreak prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrBreak} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrBreak) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreakOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + loopId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.loopId_ = loopId_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.label_ = label_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.getDefaultInstance()) return this; + if (other.hasLoopId()) { + setLoopId(other.getLoopId()); + } + if (other.hasLabel()) { + mergeLabel(other.getLabel()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasLoopId()) { + + return false; + } + if (hasLabel()) { + if (!getLabel().isInitialized()) { + + 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.KotlinIr.IrBreak parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int loopId_ ; + /** + * required int32 loop_id = 1; + */ + public boolean hasLoopId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 loop_id = 1; + */ + public int getLoopId() { + return loopId_; + } + /** + * required int32 loop_id = 1; + */ + public Builder setLoopId(int value) { + bitField0_ |= 0x00000001; + loopId_ = value; + + return this; + } + /** + * required int32 loop_id = 1; + */ + public Builder clearLoopId() { + bitField0_ = (bitField0_ & ~0x00000001); + loopId_ = 0; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getLabel() { + return label_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public Builder setLabel(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + label_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public Builder setLabel( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + label_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public Builder mergeLabel(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + label_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + label_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(label_).mergeFrom(value).buildPartial(); + } else { + label_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public Builder clearLabel() { + label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrBreak) + } + + static { + defaultInstance = new IrBreak(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrBreak) + } + + public interface IrBlockOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrBlock) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required bool is_lambda_origin = 1; + */ + boolean hasIsLambdaOrigin(); + /** + * required bool is_lambda_origin = 1; + */ + boolean getIsLambdaOrigin(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + java.util.List + getStatementList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getStatement(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + int getStatementCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrBlock} + */ + public static final class IrBlock extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrBlock) + IrBlockOrBuilder { + // Use IrBlock.newBuilder() to construct. + private IrBlock(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrBlock(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrBlock defaultInstance; + public static IrBlock getDefaultInstance() { + return defaultInstance; + } + + public IrBlock getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrBlock( + 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); + 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; + isLambdaOrigin_ = input.readBool(); + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + statement_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + statement_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + statement_ = java.util.Collections.unmodifiableList(statement_); + } + 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 IrBlock parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrBlock(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int IS_LAMBDA_ORIGIN_FIELD_NUMBER = 1; + private boolean isLambdaOrigin_; + /** + * required bool is_lambda_origin = 1; + */ + public boolean hasIsLambdaOrigin() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required bool is_lambda_origin = 1; + */ + public boolean getIsLambdaOrigin() { + return isLambdaOrigin_; + } + + public static final int STATEMENT_FIELD_NUMBER = 2; + private java.util.List statement_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public java.util.List getStatementList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public java.util.List + getStatementOrBuilderList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrBuilder getStatementOrBuilder( + int index) { + return statement_.get(index); + } + + private void initFields() { + isLambdaOrigin_ = false; + statement_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasIsLambdaOrigin()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getStatementCount(); i++) { + if (!getStatement(i).isInitialized()) { + 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.writeBool(1, isLambdaOrigin_); + } + for (int i = 0; i < statement_.size(); i++) { + output.writeMessage(2, statement_.get(i)); + } + 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 + .computeBoolSize(1, isLambdaOrigin_); + } + for (int i = 0; i < statement_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, statement_.get(i)); + } + 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.KotlinIr.IrBlock 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.KotlinIr.IrBlock 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.KotlinIr.IrBlock parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock 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.KotlinIr.IrBlock parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock 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.KotlinIr.IrBlock parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock 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.KotlinIr.IrBlock parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock 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.KotlinIr.IrBlock prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrBlock} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrBlock) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + isLambdaOrigin_ = false; + bitField0_ = (bitField0_ & ~0x00000001); + statement_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.isLambdaOrigin_ = isLambdaOrigin_; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + statement_ = java.util.Collections.unmodifiableList(statement_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.statement_ = statement_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.getDefaultInstance()) return this; + if (other.hasIsLambdaOrigin()) { + setIsLambdaOrigin(other.getIsLambdaOrigin()); + } + if (!other.statement_.isEmpty()) { + if (statement_.isEmpty()) { + statement_ = other.statement_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureStatementIsMutable(); + statement_.addAll(other.statement_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasIsLambdaOrigin()) { + + return false; + } + for (int i = 0; i < getStatementCount(); i++) { + if (!getStatement(i).isInitialized()) { + + 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.KotlinIr.IrBlock parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private boolean isLambdaOrigin_ ; + /** + * required bool is_lambda_origin = 1; + */ + public boolean hasIsLambdaOrigin() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required bool is_lambda_origin = 1; + */ + public boolean getIsLambdaOrigin() { + return isLambdaOrigin_; + } + /** + * required bool is_lambda_origin = 1; + */ + public Builder setIsLambdaOrigin(boolean value) { + bitField0_ |= 0x00000001; + isLambdaOrigin_ = value; + + return this; + } + /** + * required bool is_lambda_origin = 1; + */ + public Builder clearIsLambdaOrigin() { + bitField0_ = (bitField0_ & ~0x00000001); + isLambdaOrigin_ = false; + + return this; + } + + private java.util.List statement_ = + java.util.Collections.emptyList(); + private void ensureStatementIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + statement_ = new java.util.ArrayList(statement_); + bitField0_ |= 0x00000002; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public java.util.List getStatementList() { + return java.util.Collections.unmodifiableList(statement_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public Builder addStatement(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public Builder addStatement( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public Builder addAllStatement( + java.lang.Iterable values) { + ensureStatementIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, statement_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public Builder clearStatement() { + statement_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; + */ + public Builder removeStatement(int index) { + ensureStatementIsMutable(); + statement_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrBlock) + } + + static { + defaultInstance = new IrBlock(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrBlock) + } + + public interface MemberAccessCommonOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + boolean hasDispatchReceiver(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getDispatchReceiver(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + boolean hasExtensionReceiver(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExtensionReceiver(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + java.util.List + getValueArgumentList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression getValueArgument(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + int getValueArgumentCount(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + boolean hasTypeArguments(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments getTypeArguments(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon} + */ + public static final class MemberAccessCommon extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon) + MemberAccessCommonOrBuilder { + // Use MemberAccessCommon.newBuilder() to construct. + private MemberAccessCommon(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private MemberAccessCommon(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final MemberAccessCommon defaultInstance; + public static MemberAccessCommon getDefaultInstance() { + return defaultInstance; + } + + public MemberAccessCommon getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private MemberAccessCommon( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = dispatchReceiver_.toBuilder(); + } + dispatchReceiver_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(dispatchReceiver_); + dispatchReceiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = extensionReceiver_.toBuilder(); + } + extensionReceiver_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(extensionReceiver_); + extensionReceiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + valueArgument_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + valueArgument_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression.PARSER, extensionRegistry)); + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = typeArguments_.toBuilder(); + } + typeArguments_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(typeArguments_); + typeArguments_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + 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 { + if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + valueArgument_ = java.util.Collections.unmodifiableList(valueArgument_); + } + 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 MemberAccessCommon parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new MemberAccessCommon(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int DISPATCH_RECEIVER_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression dispatchReceiver_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + public boolean hasDispatchReceiver() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getDispatchReceiver() { + return dispatchReceiver_; + } + + public static final int EXTENSION_RECEIVER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression extensionReceiver_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + public boolean hasExtensionReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExtensionReceiver() { + return extensionReceiver_; + } + + public static final int VALUE_ARGUMENT_FIELD_NUMBER = 3; + private java.util.List valueArgument_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public java.util.List getValueArgumentList() { + return valueArgument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public java.util.List + getValueArgumentOrBuilderList() { + return valueArgument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public int getValueArgumentCount() { + return valueArgument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression getValueArgument(int index) { + return valueArgument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpressionOrBuilder getValueArgumentOrBuilder( + int index) { + return valueArgument_.get(index); + } + + public static final int TYPE_ARGUMENTS_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments typeArguments_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + public boolean hasTypeArguments() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments getTypeArguments() { + return typeArguments_; + } + + private void initFields() { + dispatchReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + extensionReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + valueArgument_ = java.util.Collections.emptyList(); + typeArguments_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasTypeArguments()) { + memoizedIsInitialized = 0; + return false; + } + if (hasDispatchReceiver()) { + if (!getDispatchReceiver().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasExtensionReceiver()) { + if (!getExtensionReceiver().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getValueArgumentCount(); i++) { + if (!getValueArgument(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getTypeArguments().isInitialized()) { + 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.writeMessage(1, dispatchReceiver_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, extensionReceiver_); + } + for (int i = 0; i < valueArgument_.size(); i++) { + output.writeMessage(3, valueArgument_.get(i)); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(4, typeArguments_); + } + 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 + .computeMessageSize(1, dispatchReceiver_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, extensionReceiver_); + } + for (int i = 0; i < valueArgument_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, valueArgument_.get(i)); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, typeArguments_); + } + 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.KotlinIr.MemberAccessCommon 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.KotlinIr.MemberAccessCommon 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.KotlinIr.MemberAccessCommon parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon 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.KotlinIr.MemberAccessCommon parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon 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.KotlinIr.MemberAccessCommon parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon 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.KotlinIr.MemberAccessCommon parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon 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.KotlinIr.MemberAccessCommon prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommonOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + dispatchReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + extensionReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + valueArgument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + typeArguments_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.dispatchReceiver_ = dispatchReceiver_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.extensionReceiver_ = extensionReceiver_; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + valueArgument_ = java.util.Collections.unmodifiableList(valueArgument_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.valueArgument_ = valueArgument_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000004; + } + result.typeArguments_ = typeArguments_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance()) return this; + if (other.hasDispatchReceiver()) { + mergeDispatchReceiver(other.getDispatchReceiver()); + } + if (other.hasExtensionReceiver()) { + mergeExtensionReceiver(other.getExtensionReceiver()); + } + if (!other.valueArgument_.isEmpty()) { + if (valueArgument_.isEmpty()) { + valueArgument_ = other.valueArgument_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureValueArgumentIsMutable(); + valueArgument_.addAll(other.valueArgument_); + } + + } + if (other.hasTypeArguments()) { + mergeTypeArguments(other.getTypeArguments()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasTypeArguments()) { + + return false; + } + if (hasDispatchReceiver()) { + if (!getDispatchReceiver().isInitialized()) { + + return false; + } + } + if (hasExtensionReceiver()) { + if (!getExtensionReceiver().isInitialized()) { + + return false; + } + } + for (int i = 0; i < getValueArgumentCount(); i++) { + if (!getValueArgument(i).isInitialized()) { + + return false; + } + } + if (!getTypeArguments().isInitialized()) { + + 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.KotlinIr.MemberAccessCommon parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression dispatchReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + public boolean hasDispatchReceiver() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getDispatchReceiver() { + return dispatchReceiver_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + public Builder setDispatchReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + dispatchReceiver_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + public Builder setDispatchReceiver( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + dispatchReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + public Builder mergeDispatchReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + dispatchReceiver_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + dispatchReceiver_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(dispatchReceiver_).mergeFrom(value).buildPartial(); + } else { + dispatchReceiver_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression dispatch_receiver = 1; + */ + public Builder clearDispatchReceiver() { + dispatchReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression extensionReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + public boolean hasExtensionReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExtensionReceiver() { + return extensionReceiver_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + public Builder setExtensionReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + extensionReceiver_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + public Builder setExtensionReceiver( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + extensionReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + public Builder mergeExtensionReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + extensionReceiver_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + extensionReceiver_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(extensionReceiver_).mergeFrom(value).buildPartial(); + } else { + extensionReceiver_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression extension_receiver = 2; + */ + public Builder clearExtensionReceiver() { + extensionReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private java.util.List valueArgument_ = + java.util.Collections.emptyList(); + private void ensureValueArgumentIsMutable() { + if (!((bitField0_ & 0x00000004) == 0x00000004)) { + valueArgument_ = new java.util.ArrayList(valueArgument_); + bitField0_ |= 0x00000004; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public java.util.List getValueArgumentList() { + return java.util.Collections.unmodifiableList(valueArgument_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public int getValueArgumentCount() { + return valueArgument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression getValueArgument(int index) { + return valueArgument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public Builder setValueArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueArgumentIsMutable(); + valueArgument_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public Builder setValueArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression.Builder builderForValue) { + ensureValueArgumentIsMutable(); + valueArgument_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public Builder addValueArgument(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueArgumentIsMutable(); + valueArgument_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public Builder addValueArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueArgumentIsMutable(); + valueArgument_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public Builder addValueArgument( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression.Builder builderForValue) { + ensureValueArgumentIsMutable(); + valueArgument_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public Builder addValueArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression.Builder builderForValue) { + ensureValueArgumentIsMutable(); + valueArgument_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public Builder addAllValueArgument( + java.lang.Iterable values) { + ensureValueArgumentIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, valueArgument_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public Builder clearValueArgument() { + valueArgument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression value_argument = 3; + */ + public Builder removeValueArgument(int index) { + ensureValueArgumentIsMutable(); + valueArgument_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments typeArguments_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + public boolean hasTypeArguments() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments getTypeArguments() { + return typeArguments_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + public Builder setTypeArguments(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments value) { + if (value == null) { + throw new NullPointerException(); + } + typeArguments_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + public Builder setTypeArguments( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.Builder builderForValue) { + typeArguments_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + public Builder mergeTypeArguments(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + typeArguments_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.getDefaultInstance()) { + typeArguments_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.newBuilder(typeArguments_).mergeFrom(value).buildPartial(); + } else { + typeArguments_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.TypeArguments type_arguments = 4; + */ + public Builder clearTypeArguments() { + typeArguments_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.TypeArguments.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon) + } + + static { + defaultInstance = new MemberAccessCommon(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon) + } + + public interface IrCallOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrCall) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive kind = 1; + */ + boolean hasKind(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive kind = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive getKind(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + boolean hasSuper(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSuper(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrCall} + */ + public static final class IrCall extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrCall) + IrCallOrBuilder { + // Use IrCall.newBuilder() to construct. + private IrCall(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrCall(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrCall defaultInstance; + public static IrCall getDefaultInstance() { + return defaultInstance; + } + + public IrCall getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrCall( + 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); + 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: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + kind_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(memberAccess_); + memberAccess_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = super_.toBuilder(); + } + super_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(super_); + super_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + 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 IrCall parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrCall(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive} + */ + public enum Primitive + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * NOT_PRIMITIVE = 1; + */ + NOT_PRIMITIVE(0, 1), + /** + * NULLARY = 2; + */ + NULLARY(1, 2), + /** + * UNARY = 3; + */ + UNARY(2, 3), + /** + * BINARY = 4; + */ + BINARY(3, 4), + ; + + /** + * NOT_PRIMITIVE = 1; + */ + public static final int NOT_PRIMITIVE_VALUE = 1; + /** + * NULLARY = 2; + */ + public static final int NULLARY_VALUE = 2; + /** + * UNARY = 3; + */ + public static final int UNARY_VALUE = 3; + /** + * BINARY = 4; + */ + public static final int BINARY_VALUE = 4; + + + public final int getNumber() { return value; } + + public static Primitive valueOf(int value) { + switch (value) { + case 1: return NOT_PRIMITIVE; + case 2: return NULLARY; + case 3: return UNARY; + case 4: return BINARY; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public Primitive findValueByNumber(int number) { + return Primitive.valueOf(number); + } + }; + + private final int value; + + private Primitive(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive) + } + + private int bitField0_; + public static final int KIND_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive kind_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive kind = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive getKind() { + return kind_; + } + + public static final int SYMBOL_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + public static final int SUPER_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol super_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + public boolean hasSuper() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSuper() { + return super_; + } + + private void initFields() { + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive.NOT_PRIMITIVE; + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasKind()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasMemberAccess()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getMemberAccess().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasSuper()) { + if (!getSuper().isInitialized()) { + 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.writeEnum(1, kind_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, symbol_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, memberAccess_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, super_); + } + 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 + .computeEnumSize(1, kind_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, symbol_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, memberAccess_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, super_); + } + 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.KotlinIr.IrCall 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.KotlinIr.IrCall 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.KotlinIr.IrCall parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall 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.KotlinIr.IrCall parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall 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.KotlinIr.IrCall parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall 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.KotlinIr.IrCall parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall 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.KotlinIr.IrCall prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrCall} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrCall) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCallOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive.NOT_PRIMITIVE; + bitField0_ = (bitField0_ & ~0x00000001); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.kind_ = kind_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.memberAccess_ = memberAccess_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.super_ = super_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.getDefaultInstance()) return this; + if (other.hasKind()) { + setKind(other.getKind()); + } + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasMemberAccess()) { + mergeMemberAccess(other.getMemberAccess()); + } + if (other.hasSuper()) { + mergeSuper(other.getSuper()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasKind()) { + + return false; + } + if (!hasSymbol()) { + + return false; + } + if (!hasMemberAccess()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getMemberAccess().isInitialized()) { + + return false; + } + if (hasSuper()) { + if (!getSuper().isInitialized()) { + + 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.KotlinIr.IrCall parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive.NOT_PRIMITIVE; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive kind = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive getKind() { + return kind_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive kind = 1; + */ + public Builder setKind(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + kind_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrCall.Primitive kind = 1; + */ + public Builder clearKind() { + bitField0_ = (bitField0_ & ~0x00000001); + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive.NOT_PRIMITIVE; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + memberAccess_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + public boolean hasSuper() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSuper() { + return super_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + public Builder setSuper(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + super_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + public Builder setSuper( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + super_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + public Builder mergeSuper(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + super_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + super_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(super_).mergeFrom(value).buildPartial(); + } else { + super_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; + */ + public Builder clearSuper() { + super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrCall) + } + + static { + defaultInstance = new IrCall(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrCall) + } + + public interface IrFunctionReferenceOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + boolean hasOrigin(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference} + */ + public static final class IrFunctionReference extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference) + IrFunctionReferenceOrBuilder { + // Use IrFunctionReference.newBuilder() to construct. + private IrFunctionReference(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrFunctionReference(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrFunctionReference defaultInstance; + public static IrFunctionReference getDefaultInstance() { + return defaultInstance; + } + + public IrFunctionReference getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrFunctionReference( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(memberAccess_); + memberAccess_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + 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 IrFunctionReference parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrFunctionReference(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int ORIGIN_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasMemberAccess()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasOrigin()) { + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getMemberAccess().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, origin_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, memberAccess_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, origin_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, memberAccess_); + } + 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.KotlinIr.IrFunctionReference 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.KotlinIr.IrFunctionReference 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.KotlinIr.IrFunctionReference parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference 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.KotlinIr.IrFunctionReference parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference 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.KotlinIr.IrFunctionReference parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference 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.KotlinIr.IrFunctionReference parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference 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.KotlinIr.IrFunctionReference prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReferenceOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.origin_ = origin_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.memberAccess_ = memberAccess_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } + if (other.hasMemberAccess()) { + mergeMemberAccess(other.getMemberAccess()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasMemberAccess()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (hasOrigin()) { + if (!getOrigin().isInitialized()) { + + return false; + } + } + if (!getMemberAccess().isInitialized()) { + + 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.KotlinIr.IrFunctionReference parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + memberAccess_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 3; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference) + } + + static { + defaultInstance = new IrFunctionReference(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference) + } + + public interface IrPropertyReferenceOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + boolean hasField(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getField(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + boolean hasGetter(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getGetter(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + boolean hasSetter(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSetter(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + boolean hasOrigin(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + boolean hasDescriptorReference(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDescriptorReference(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference} + */ + public static final class IrPropertyReference extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference) + IrPropertyReferenceOrBuilder { + // Use IrPropertyReference.newBuilder() to construct. + private IrPropertyReference(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrPropertyReference(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrPropertyReference defaultInstance; + public static IrPropertyReference getDefaultInstance() { + return defaultInstance; + } + + public IrPropertyReference getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrPropertyReference( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = field_.toBuilder(); + } + field_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(field_); + field_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = getter_.toBuilder(); + } + getter_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(getter_); + getter_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = setter_.toBuilder(); + } + setter_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(setter_); + setter_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(memberAccess_); + memberAccess_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + case 50: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.Builder subBuilder = null; + if (((bitField0_ & 0x00000020) == 0x00000020)) { + subBuilder = descriptorReference_.toBuilder(); + } + descriptorReference_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(descriptorReference_); + descriptorReference_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000020; + 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 IrPropertyReference parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrPropertyReference(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int FIELD_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol field_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + public boolean hasField() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getField() { + return field_; + } + + public static final int GETTER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getter_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + public boolean hasGetter() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getGetter() { + return getter_; + } + + public static final int SETTER_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol setter_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + public boolean hasSetter() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSetter() { + return setter_; + } + + public static final int ORIGIN_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + public static final int DESCRIPTOR_REFERENCE_FIELD_NUMBER = 6; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference descriptorReference_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + public boolean hasDescriptorReference() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDescriptorReference() { + return descriptorReference_; + } + + private void initFields() { + field_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + getter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + setter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasMemberAccess()) { + memoizedIsInitialized = 0; + return false; + } + if (hasField()) { + if (!getField().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasGetter()) { + if (!getGetter().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasSetter()) { + if (!getSetter().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasOrigin()) { + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getMemberAccess().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasDescriptorReference()) { + if (!getDescriptorReference().isInitialized()) { + 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.writeMessage(1, field_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, getter_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, setter_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, origin_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(5, memberAccess_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeMessage(6, descriptorReference_); + } + 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 + .computeMessageSize(1, field_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, getter_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, setter_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, origin_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, memberAccess_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(6, descriptorReference_); + } + 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.KotlinIr.IrPropertyReference 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.KotlinIr.IrPropertyReference 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.KotlinIr.IrPropertyReference parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference 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.KotlinIr.IrPropertyReference parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference 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.KotlinIr.IrPropertyReference parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference 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.KotlinIr.IrPropertyReference parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference 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.KotlinIr.IrPropertyReference prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReferenceOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + field_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + getter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + setter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); + descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.field_ = field_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.getter_ = getter_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.setter_ = setter_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.origin_ = origin_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.memberAccess_ = memberAccess_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.descriptorReference_ = descriptorReference_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.getDefaultInstance()) return this; + if (other.hasField()) { + mergeField(other.getField()); + } + if (other.hasGetter()) { + mergeGetter(other.getGetter()); + } + if (other.hasSetter()) { + mergeSetter(other.getSetter()); + } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } + if (other.hasMemberAccess()) { + mergeMemberAccess(other.getMemberAccess()); + } + if (other.hasDescriptorReference()) { + mergeDescriptorReference(other.getDescriptorReference()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasMemberAccess()) { + + return false; + } + if (hasField()) { + if (!getField().isInitialized()) { + + return false; + } + } + if (hasGetter()) { + if (!getGetter().isInitialized()) { + + return false; + } + } + if (hasSetter()) { + if (!getSetter().isInitialized()) { + + return false; + } + } + if (hasOrigin()) { + if (!getOrigin().isInitialized()) { + + return false; + } + } + if (!getMemberAccess().isInitialized()) { + + return false; + } + if (hasDescriptorReference()) { + if (!getDescriptorReference().isInitialized()) { + + 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.KotlinIr.IrPropertyReference parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol field_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + public boolean hasField() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getField() { + return field_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + public Builder setField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + field_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + public Builder setField( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + field_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + public Builder mergeField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + field_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + field_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(field_).mergeFrom(value).buildPartial(); + } else { + field_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol field = 1; + */ + public Builder clearField() { + field_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + public boolean hasGetter() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getGetter() { + return getter_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + public Builder setGetter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + getter_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + public Builder setGetter( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + getter_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + public Builder mergeGetter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + getter_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + getter_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(getter_).mergeFrom(value).buildPartial(); + } else { + getter_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol getter = 2; + */ + public Builder clearGetter() { + getter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol setter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + public boolean hasSetter() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSetter() { + return setter_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + public Builder setSetter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + setter_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + public Builder setSetter( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + setter_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + public Builder mergeSetter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + setter_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + setter_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(setter_).mergeFrom(value).buildPartial(); + } else { + setter_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol setter = 3; + */ + public Builder clearSetter() { + setter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + memberAccess_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 5; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public boolean hasDescriptorReference() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDescriptorReference() { + return descriptorReference_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder setDescriptorReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference value) { + if (value == null) { + throw new NullPointerException(); + } + descriptorReference_ = value; + + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder setDescriptorReference( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.Builder builderForValue) { + descriptorReference_ = builderForValue.build(); + + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder mergeDescriptorReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference value) { + if (((bitField0_ & 0x00000020) == 0x00000020) && + descriptorReference_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance()) { + descriptorReference_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.newBuilder(descriptorReference_).mergeFrom(value).buildPartial(); + } else { + descriptorReference_ = value; + } + + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 6; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder clearDescriptorReference() { + descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference) + } + + static { + defaultInstance = new IrPropertyReference(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference) + } + + public interface IrCompositeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrComposite) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + java.util.List + getStatementList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getStatement(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + int getStatementCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrComposite} + */ + public static final class IrComposite extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrComposite) + IrCompositeOrBuilder { + // Use IrComposite.newBuilder() to construct. + private IrComposite(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrComposite(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrComposite defaultInstance; + public static IrComposite getDefaultInstance() { + return defaultInstance; + } + + public IrComposite getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrComposite( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + statement_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = java.util.Collections.unmodifiableList(statement_); + } + 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 IrComposite parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrComposite(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int STATEMENT_FIELD_NUMBER = 1; + private java.util.List statement_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public java.util.List getStatementList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public java.util.List + getStatementOrBuilderList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrBuilder getStatementOrBuilder( + int index) { + return statement_.get(index); + } + + private void initFields() { + statement_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getStatementCount(); i++) { + if (!getStatement(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < statement_.size(); i++) { + output.writeMessage(1, statement_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < statement_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, statement_.get(i)); + } + 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.KotlinIr.IrComposite 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.KotlinIr.IrComposite 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.KotlinIr.IrComposite parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite 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.KotlinIr.IrComposite parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite 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.KotlinIr.IrComposite parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite 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.KotlinIr.IrComposite parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite 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.KotlinIr.IrComposite prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrComposite} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrComposite) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCompositeOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + statement_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = java.util.Collections.unmodifiableList(statement_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.statement_ = statement_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.getDefaultInstance()) return this; + if (!other.statement_.isEmpty()) { + if (statement_.isEmpty()) { + statement_ = other.statement_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureStatementIsMutable(); + statement_.addAll(other.statement_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getStatementCount(); i++) { + if (!getStatement(i).isInitialized()) { + + 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.KotlinIr.IrComposite parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List statement_ = + java.util.Collections.emptyList(); + private void ensureStatementIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = new java.util.ArrayList(statement_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public java.util.List getStatementList() { + return java.util.Collections.unmodifiableList(statement_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addStatement(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addStatement( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addAllStatement( + java.lang.Iterable values) { + ensureStatementIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, statement_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder clearStatement() { + statement_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder removeStatement(int index) { + ensureStatementIsMutable(); + statement_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrComposite) + } + + static { + defaultInstance = new IrComposite(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrComposite) + } + + public interface IrClassReferenceOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrClassReference) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + boolean hasClassSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getClassSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + boolean hasClassType(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getClassType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrClassReference} + */ + public static final class IrClassReference extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrClassReference) + IrClassReferenceOrBuilder { + // Use IrClassReference.newBuilder() to construct. + private IrClassReference(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrClassReference(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrClassReference defaultInstance; + public static IrClassReference getDefaultInstance() { + return defaultInstance; + } + + public IrClassReference getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrClassReference( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = classSymbol_.toBuilder(); + } + classSymbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(classSymbol_); + classSymbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = classType_.toBuilder(); + } + classType_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(classType_); + classType_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrClassReference parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrClassReference(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int CLASS_SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol classSymbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + public boolean hasClassSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getClassSymbol() { + return classSymbol_; + } + + public static final int CLASS_TYPE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex classType_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + public boolean hasClassType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getClassType() { + return classType_; + } + + private void initFields() { + classSymbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + classType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasClassSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasClassType()) { + memoizedIsInitialized = 0; + return false; + } + if (!getClassSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getClassType().isInitialized()) { + 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.writeMessage(1, classSymbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, classType_); + } + 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 + .computeMessageSize(1, classSymbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, classType_); + } + 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.KotlinIr.IrClassReference 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.KotlinIr.IrClassReference 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.KotlinIr.IrClassReference parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference 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.KotlinIr.IrClassReference parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference 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.KotlinIr.IrClassReference parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference 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.KotlinIr.IrClassReference parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference 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.KotlinIr.IrClassReference prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrClassReference} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrClassReference) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReferenceOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + classSymbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + classType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.classSymbol_ = classSymbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.classType_ = classType_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.getDefaultInstance()) return this; + if (other.hasClassSymbol()) { + mergeClassSymbol(other.getClassSymbol()); + } + if (other.hasClassType()) { + mergeClassType(other.getClassType()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasClassSymbol()) { + + return false; + } + if (!hasClassType()) { + + return false; + } + if (!getClassSymbol().isInitialized()) { + + return false; + } + if (!getClassType().isInitialized()) { + + 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.KotlinIr.IrClassReference parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol classSymbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + public boolean hasClassSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getClassSymbol() { + return classSymbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + public Builder setClassSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + classSymbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + public Builder setClassSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + classSymbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + public Builder mergeClassSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + classSymbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + classSymbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(classSymbol_).mergeFrom(value).buildPartial(); + } else { + classSymbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol class_symbol = 1; + */ + public Builder clearClassSymbol() { + classSymbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex classType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + public boolean hasClassType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getClassType() { + return classType_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + public Builder setClassType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + classType_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + public Builder setClassType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + classType_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + public Builder mergeClassType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + classType_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + classType_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(classType_).mergeFrom(value).buildPartial(); + } else { + classType_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex class_type = 2; + */ + public Builder clearClassType() { + classType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrClassReference) + } + + static { + defaultInstance = new IrClassReference(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrClassReference) + } + + public interface IrConstOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrConst) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional bool null = 1; + */ + boolean hasNull(); + /** + * optional bool null = 1; + */ + boolean getNull(); + + /** + * optional bool boolean = 2; + */ + boolean hasBoolean(); + /** + * optional bool boolean = 2; + */ + boolean getBoolean(); + + /** + * optional int32 char = 3; + */ + boolean hasChar(); + /** + * optional int32 char = 3; + */ + int getChar(); + + /** + * optional int32 byte = 4; + */ + boolean hasByte(); + /** + * optional int32 byte = 4; + */ + int getByte(); + + /** + * optional int32 short = 5; + */ + boolean hasShort(); + /** + * optional int32 short = 5; + */ + int getShort(); + + /** + * optional int32 int = 6; + */ + boolean hasInt(); + /** + * optional int32 int = 6; + */ + int getInt(); + + /** + * optional int64 long = 7; + */ + boolean hasLong(); + /** + * optional int64 long = 7; + */ + long getLong(); + + /** + * optional float float = 8; + */ + boolean hasFloat(); + /** + * optional float float = 8; + */ + float getFloat(); + + /** + * optional double double = 9; + */ + boolean hasDouble(); + /** + * optional double double = 9; + */ + double getDouble(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + boolean hasString(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getString(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrConst} + */ + public static final class IrConst extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrConst) + IrConstOrBuilder { + // Use IrConst.newBuilder() to construct. + private IrConst(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrConst(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrConst defaultInstance; + public static IrConst getDefaultInstance() { + return defaultInstance; + } + + public IrConst getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrConst( + 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); + 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: { + valueCase_ = 1; + value_ = input.readBool(); + break; + } + case 16: { + valueCase_ = 2; + value_ = input.readBool(); + break; + } + case 24: { + valueCase_ = 3; + value_ = input.readInt32(); + break; + } + case 32: { + valueCase_ = 4; + value_ = input.readInt32(); + break; + } + case 40: { + valueCase_ = 5; + value_ = input.readInt32(); + break; + } + case 48: { + valueCase_ = 6; + value_ = input.readInt32(); + break; + } + case 56: { + valueCase_ = 7; + value_ = input.readInt64(); + break; + } + case 69: { + valueCase_ = 8; + value_ = input.readFloat(); + break; + } + case 73: { + valueCase_ = 9; + value_ = input.readDouble(); + break; + } + case 82: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (valueCase_ == 10) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) value_).toBuilder(); + } + value_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) value_); + value_ = subBuilder.buildPartial(); + } + valueCase_ = 10; + 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 IrConst parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrConst(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + private int valueCase_ = 0; + private java.lang.Object value_; + public enum ValueCase + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + NULL(1), + BOOLEAN(2), + CHAR(3), + BYTE(4), + SHORT(5), + INT(6), + LONG(7), + FLOAT(8), + DOUBLE(9), + STRING(10), + VALUE_NOT_SET(0); + private int value = 0; + private ValueCase(int value) { + this.value = value; + } + public static ValueCase valueOf(int value) { + switch (value) { + case 1: return NULL; + case 2: return BOOLEAN; + case 3: return CHAR; + case 4: return BYTE; + case 5: return SHORT; + case 6: return INT; + case 7: return LONG; + case 8: return FLOAT; + case 9: return DOUBLE; + case 10: return STRING; + case 0: return VALUE_NOT_SET; + default: throw new java.lang.IllegalArgumentException( + "Value is undefined for this oneof enum."); + } + } + public int getNumber() { + return this.value; + } + }; + + public ValueCase + getValueCase() { + return ValueCase.valueOf( + valueCase_); + } + + public static final int NULL_FIELD_NUMBER = 1; + /** + * optional bool null = 1; + */ + public boolean hasNull() { + return valueCase_ == 1; + } + /** + * optional bool null = 1; + */ + public boolean getNull() { + if (valueCase_ == 1) { + return (java.lang.Boolean) value_; + } + return false; + } + + public static final int BOOLEAN_FIELD_NUMBER = 2; + /** + * optional bool boolean = 2; + */ + public boolean hasBoolean() { + return valueCase_ == 2; + } + /** + * optional bool boolean = 2; + */ + public boolean getBoolean() { + if (valueCase_ == 2) { + return (java.lang.Boolean) value_; + } + return false; + } + + public static final int CHAR_FIELD_NUMBER = 3; + /** + * optional int32 char = 3; + */ + public boolean hasChar() { + return valueCase_ == 3; + } + /** + * optional int32 char = 3; + */ + public int getChar() { + if (valueCase_ == 3) { + return (java.lang.Integer) value_; + } + return 0; + } + + public static final int BYTE_FIELD_NUMBER = 4; + /** + * optional int32 byte = 4; + */ + public boolean hasByte() { + return valueCase_ == 4; + } + /** + * optional int32 byte = 4; + */ + public int getByte() { + if (valueCase_ == 4) { + return (java.lang.Integer) value_; + } + return 0; + } + + public static final int SHORT_FIELD_NUMBER = 5; + /** + * optional int32 short = 5; + */ + public boolean hasShort() { + return valueCase_ == 5; + } + /** + * optional int32 short = 5; + */ + public int getShort() { + if (valueCase_ == 5) { + return (java.lang.Integer) value_; + } + return 0; + } + + public static final int INT_FIELD_NUMBER = 6; + /** + * optional int32 int = 6; + */ + public boolean hasInt() { + return valueCase_ == 6; + } + /** + * optional int32 int = 6; + */ + public int getInt() { + if (valueCase_ == 6) { + return (java.lang.Integer) value_; + } + return 0; + } + + public static final int LONG_FIELD_NUMBER = 7; + /** + * optional int64 long = 7; + */ + public boolean hasLong() { + return valueCase_ == 7; + } + /** + * optional int64 long = 7; + */ + public long getLong() { + if (valueCase_ == 7) { + return (java.lang.Long) value_; + } + return 0L; + } + + public static final int FLOAT_FIELD_NUMBER = 8; + /** + * optional float float = 8; + */ + public boolean hasFloat() { + return valueCase_ == 8; + } + /** + * optional float float = 8; + */ + public float getFloat() { + if (valueCase_ == 8) { + return (java.lang.Float) value_; + } + return 0F; + } + + public static final int DOUBLE_FIELD_NUMBER = 9; + /** + * optional double double = 9; + */ + public boolean hasDouble() { + return valueCase_ == 9; + } + /** + * optional double double = 9; + */ + public double getDouble() { + if (valueCase_ == 9) { + return (java.lang.Double) value_; + } + return 0D; + } + + public static final int STRING_FIELD_NUMBER = 10; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + public boolean hasString() { + return valueCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getString() { + if (valueCase_ == 10) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) value_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + } + + private void initFields() { + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (hasString()) { + if (!getString().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (valueCase_ == 1) { + output.writeBool( + 1, (boolean)((java.lang.Boolean) value_)); + } + if (valueCase_ == 2) { + output.writeBool( + 2, (boolean)((java.lang.Boolean) value_)); + } + if (valueCase_ == 3) { + output.writeInt32( + 3, (int)((java.lang.Integer) value_)); + } + if (valueCase_ == 4) { + output.writeInt32( + 4, (int)((java.lang.Integer) value_)); + } + if (valueCase_ == 5) { + output.writeInt32( + 5, (int)((java.lang.Integer) value_)); + } + if (valueCase_ == 6) { + output.writeInt32( + 6, (int)((java.lang.Integer) value_)); + } + if (valueCase_ == 7) { + output.writeInt64( + 7, (long)((java.lang.Long) value_)); + } + if (valueCase_ == 8) { + output.writeFloat( + 8, (float)((java.lang.Float) value_)); + } + if (valueCase_ == 9) { + output.writeDouble( + 9, (double)((java.lang.Double) value_)); + } + if (valueCase_ == 10) { + output.writeMessage(10, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) value_); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (valueCase_ == 1) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize( + 1, (boolean)((java.lang.Boolean) value_)); + } + if (valueCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize( + 2, (boolean)((java.lang.Boolean) value_)); + } + if (valueCase_ == 3) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32Size( + 3, (int)((java.lang.Integer) value_)); + } + if (valueCase_ == 4) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32Size( + 4, (int)((java.lang.Integer) value_)); + } + if (valueCase_ == 5) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32Size( + 5, (int)((java.lang.Integer) value_)); + } + if (valueCase_ == 6) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32Size( + 6, (int)((java.lang.Integer) value_)); + } + if (valueCase_ == 7) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt64Size( + 7, (long)((java.lang.Long) value_)); + } + if (valueCase_ == 8) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeFloatSize( + 8, (float)((java.lang.Float) value_)); + } + if (valueCase_ == 9) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeDoubleSize( + 9, (double)((java.lang.Double) value_)); + } + if (valueCase_ == 10) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(10, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) value_); + } + 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.KotlinIr.IrConst 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.KotlinIr.IrConst 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.KotlinIr.IrConst parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst 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.KotlinIr.IrConst parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst 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.KotlinIr.IrConst parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst 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.KotlinIr.IrConst parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst 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.KotlinIr.IrConst prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrConst} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrConst) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + valueCase_ = 0; + value_ = null; + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (valueCase_ == 1) { + result.value_ = value_; + } + if (valueCase_ == 2) { + result.value_ = value_; + } + if (valueCase_ == 3) { + result.value_ = value_; + } + if (valueCase_ == 4) { + result.value_ = value_; + } + if (valueCase_ == 5) { + result.value_ = value_; + } + if (valueCase_ == 6) { + result.value_ = value_; + } + if (valueCase_ == 7) { + result.value_ = value_; + } + if (valueCase_ == 8) { + result.value_ = value_; + } + if (valueCase_ == 9) { + result.value_ = value_; + } + if (valueCase_ == 10) { + result.value_ = value_; + } + result.bitField0_ = to_bitField0_; + result.valueCase_ = valueCase_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.getDefaultInstance()) return this; + switch (other.getValueCase()) { + case NULL: { + setNull(other.getNull()); + break; + } + case BOOLEAN: { + setBoolean(other.getBoolean()); + break; + } + case CHAR: { + setChar(other.getChar()); + break; + } + case BYTE: { + setByte(other.getByte()); + break; + } + case SHORT: { + setShort(other.getShort()); + break; + } + case INT: { + setInt(other.getInt()); + break; + } + case LONG: { + setLong(other.getLong()); + break; + } + case FLOAT: { + setFloat(other.getFloat()); + break; + } + case DOUBLE: { + setDouble(other.getDouble()); + break; + } + case STRING: { + mergeString(other.getString()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (hasString()) { + if (!getString().isInitialized()) { + + 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.KotlinIr.IrConst parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int valueCase_ = 0; + private java.lang.Object value_; + public ValueCase + getValueCase() { + return ValueCase.valueOf( + valueCase_); + } + + public Builder clearValue() { + valueCase_ = 0; + value_ = null; + return this; + } + + private int bitField0_; + + /** + * optional bool null = 1; + */ + public boolean hasNull() { + return valueCase_ == 1; + } + /** + * optional bool null = 1; + */ + public boolean getNull() { + if (valueCase_ == 1) { + return (java.lang.Boolean) value_; + } + return false; + } + /** + * optional bool null = 1; + */ + public Builder setNull(boolean value) { + valueCase_ = 1; + value_ = value; + + return this; + } + /** + * optional bool null = 1; + */ + public Builder clearNull() { + if (valueCase_ == 1) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + /** + * optional bool boolean = 2; + */ + public boolean hasBoolean() { + return valueCase_ == 2; + } + /** + * optional bool boolean = 2; + */ + public boolean getBoolean() { + if (valueCase_ == 2) { + return (java.lang.Boolean) value_; + } + return false; + } + /** + * optional bool boolean = 2; + */ + public Builder setBoolean(boolean value) { + valueCase_ = 2; + value_ = value; + + return this; + } + /** + * optional bool boolean = 2; + */ + public Builder clearBoolean() { + if (valueCase_ == 2) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + /** + * optional int32 char = 3; + */ + public boolean hasChar() { + return valueCase_ == 3; + } + /** + * optional int32 char = 3; + */ + public int getChar() { + if (valueCase_ == 3) { + return (java.lang.Integer) value_; + } + return 0; + } + /** + * optional int32 char = 3; + */ + public Builder setChar(int value) { + valueCase_ = 3; + value_ = value; + + return this; + } + /** + * optional int32 char = 3; + */ + public Builder clearChar() { + if (valueCase_ == 3) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + /** + * optional int32 byte = 4; + */ + public boolean hasByte() { + return valueCase_ == 4; + } + /** + * optional int32 byte = 4; + */ + public int getByte() { + if (valueCase_ == 4) { + return (java.lang.Integer) value_; + } + return 0; + } + /** + * optional int32 byte = 4; + */ + public Builder setByte(int value) { + valueCase_ = 4; + value_ = value; + + return this; + } + /** + * optional int32 byte = 4; + */ + public Builder clearByte() { + if (valueCase_ == 4) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + /** + * optional int32 short = 5; + */ + public boolean hasShort() { + return valueCase_ == 5; + } + /** + * optional int32 short = 5; + */ + public int getShort() { + if (valueCase_ == 5) { + return (java.lang.Integer) value_; + } + return 0; + } + /** + * optional int32 short = 5; + */ + public Builder setShort(int value) { + valueCase_ = 5; + value_ = value; + + return this; + } + /** + * optional int32 short = 5; + */ + public Builder clearShort() { + if (valueCase_ == 5) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + /** + * optional int32 int = 6; + */ + public boolean hasInt() { + return valueCase_ == 6; + } + /** + * optional int32 int = 6; + */ + public int getInt() { + if (valueCase_ == 6) { + return (java.lang.Integer) value_; + } + return 0; + } + /** + * optional int32 int = 6; + */ + public Builder setInt(int value) { + valueCase_ = 6; + value_ = value; + + return this; + } + /** + * optional int32 int = 6; + */ + public Builder clearInt() { + if (valueCase_ == 6) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + /** + * optional int64 long = 7; + */ + public boolean hasLong() { + return valueCase_ == 7; + } + /** + * optional int64 long = 7; + */ + public long getLong() { + if (valueCase_ == 7) { + return (java.lang.Long) value_; + } + return 0L; + } + /** + * optional int64 long = 7; + */ + public Builder setLong(long value) { + valueCase_ = 7; + value_ = value; + + return this; + } + /** + * optional int64 long = 7; + */ + public Builder clearLong() { + if (valueCase_ == 7) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + /** + * optional float float = 8; + */ + public boolean hasFloat() { + return valueCase_ == 8; + } + /** + * optional float float = 8; + */ + public float getFloat() { + if (valueCase_ == 8) { + return (java.lang.Float) value_; + } + return 0F; + } + /** + * optional float float = 8; + */ + public Builder setFloat(float value) { + valueCase_ = 8; + value_ = value; + + return this; + } + /** + * optional float float = 8; + */ + public Builder clearFloat() { + if (valueCase_ == 8) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + /** + * optional double double = 9; + */ + public boolean hasDouble() { + return valueCase_ == 9; + } + /** + * optional double double = 9; + */ + public double getDouble() { + if (valueCase_ == 9) { + return (java.lang.Double) value_; + } + return 0D; + } + /** + * optional double double = 9; + */ + public Builder setDouble(double value) { + valueCase_ = 9; + value_ = value; + + return this; + } + /** + * optional double double = 9; + */ + public Builder clearDouble() { + if (valueCase_ == 9) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + public boolean hasString() { + return valueCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getString() { + if (valueCase_ == 10) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) value_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + public Builder setString(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + + valueCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + public Builder setString( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + value_ = builderForValue.build(); + + valueCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + public Builder mergeString(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (valueCase_ == 10 && + value_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String) value_) + .mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + + valueCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String string = 10; + */ + public Builder clearString() { + if (valueCase_ == 10) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrConst) + } + + static { + defaultInstance = new IrConst(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrConst) + } + + public interface IrContinueOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrContinue) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 loop_id = 1; + */ + boolean hasLoopId(); + /** + * required int32 loop_id = 1; + */ + int getLoopId(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + boolean hasLabel(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getLabel(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrContinue} + */ + public static final class IrContinue extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrContinue) + IrContinueOrBuilder { + // Use IrContinue.newBuilder() to construct. + private IrContinue(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrContinue(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrContinue defaultInstance; + public static IrContinue getDefaultInstance() { + return defaultInstance; + } + + public IrContinue getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrContinue( + 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); + 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; + loopId_ = input.readInt32(); + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = label_.toBuilder(); + } + label_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(label_); + label_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrContinue parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrContinue(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int LOOP_ID_FIELD_NUMBER = 1; + private int loopId_; + /** + * required int32 loop_id = 1; + */ + public boolean hasLoopId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 loop_id = 1; + */ + public int getLoopId() { + return loopId_; + } + + public static final int LABEL_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String label_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getLabel() { + return label_; + } + + private void initFields() { + loopId_ = 0; + label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasLoopId()) { + memoizedIsInitialized = 0; + return false; + } + if (hasLabel()) { + if (!getLabel().isInitialized()) { + 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, loopId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, label_); + } + 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, loopId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, label_); + } + 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.KotlinIr.IrContinue 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.KotlinIr.IrContinue 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.KotlinIr.IrContinue parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue 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.KotlinIr.IrContinue parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue 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.KotlinIr.IrContinue parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue 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.KotlinIr.IrContinue parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue 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.KotlinIr.IrContinue prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrContinue} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrContinue) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinueOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + loopId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.loopId_ = loopId_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.label_ = label_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.getDefaultInstance()) return this; + if (other.hasLoopId()) { + setLoopId(other.getLoopId()); + } + if (other.hasLabel()) { + mergeLabel(other.getLabel()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasLoopId()) { + + return false; + } + if (hasLabel()) { + if (!getLabel().isInitialized()) { + + 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.KotlinIr.IrContinue parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int loopId_ ; + /** + * required int32 loop_id = 1; + */ + public boolean hasLoopId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 loop_id = 1; + */ + public int getLoopId() { + return loopId_; + } + /** + * required int32 loop_id = 1; + */ + public Builder setLoopId(int value) { + bitField0_ |= 0x00000001; + loopId_ = value; + + return this; + } + /** + * required int32 loop_id = 1; + */ + public Builder clearLoopId() { + bitField0_ = (bitField0_ & ~0x00000001); + loopId_ = 0; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getLabel() { + return label_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public Builder setLabel(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + label_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public Builder setLabel( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + label_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public Builder mergeLabel(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + label_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + label_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(label_).mergeFrom(value).buildPartial(); + } else { + label_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 2; + */ + public Builder clearLabel() { + label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrContinue) + } + + static { + defaultInstance = new IrContinue(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrContinue) + } + + public interface IrDelegatingConstructorCallOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall} + */ + public static final class IrDelegatingConstructorCall extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall) + IrDelegatingConstructorCallOrBuilder { + // Use IrDelegatingConstructorCall.newBuilder() to construct. + private IrDelegatingConstructorCall(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDelegatingConstructorCall(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDelegatingConstructorCall defaultInstance; + public static IrDelegatingConstructorCall getDefaultInstance() { + return defaultInstance; + } + + public IrDelegatingConstructorCall getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDelegatingConstructorCall( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(memberAccess_); + memberAccess_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrDelegatingConstructorCall parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDelegatingConstructorCall(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasMemberAccess()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getMemberAccess().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, memberAccess_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, memberAccess_); + } + 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.KotlinIr.IrDelegatingConstructorCall 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.KotlinIr.IrDelegatingConstructorCall 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.KotlinIr.IrDelegatingConstructorCall parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall 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.KotlinIr.IrDelegatingConstructorCall parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall 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.KotlinIr.IrDelegatingConstructorCall parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall 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.KotlinIr.IrDelegatingConstructorCall parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall 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.KotlinIr.IrDelegatingConstructorCall prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCallOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.memberAccess_ = memberAccess_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasMemberAccess()) { + mergeMemberAccess(other.getMemberAccess()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasMemberAccess()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getMemberAccess().isInitialized()) { + + 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.KotlinIr.IrDelegatingConstructorCall parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + memberAccess_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall) + } + + static { + defaultInstance = new IrDelegatingConstructorCall(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall) + } + + public interface IrDoWhileOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrDoWhile) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + boolean hasLoop(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop getLoop(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDoWhile} + */ + public static final class IrDoWhile extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrDoWhile) + IrDoWhileOrBuilder { + // Use IrDoWhile.newBuilder() to construct. + private IrDoWhile(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDoWhile(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDoWhile defaultInstance; + public static IrDoWhile getDefaultInstance() { + return defaultInstance; + } + + public IrDoWhile getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDoWhile( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = loop_.toBuilder(); + } + loop_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(loop_); + loop_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrDoWhile parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDoWhile(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int LOOP_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop loop_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public boolean hasLoop() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop getLoop() { + return loop_; + } + + private void initFields() { + loop_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasLoop()) { + memoizedIsInitialized = 0; + return false; + } + if (!getLoop().isInitialized()) { + 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.writeMessage(1, loop_); + } + 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 + .computeMessageSize(1, loop_); + } + 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.KotlinIr.IrDoWhile 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.KotlinIr.IrDoWhile 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.KotlinIr.IrDoWhile parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile 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.KotlinIr.IrDoWhile parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile 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.KotlinIr.IrDoWhile parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile 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.KotlinIr.IrDoWhile parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile 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.KotlinIr.IrDoWhile prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDoWhile} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrDoWhile) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhileOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + loop_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.loop_ = loop_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.getDefaultInstance()) return this; + if (other.hasLoop()) { + mergeLoop(other.getLoop()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasLoop()) { + + return false; + } + if (!getLoop().isInitialized()) { + + 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.KotlinIr.IrDoWhile parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop loop_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public boolean hasLoop() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop getLoop() { + return loop_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public Builder setLoop(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop value) { + if (value == null) { + throw new NullPointerException(); + } + loop_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public Builder setLoop( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.Builder builderForValue) { + loop_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public Builder mergeLoop(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + loop_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance()) { + loop_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.newBuilder(loop_).mergeFrom(value).buildPartial(); + } else { + loop_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public Builder clearLoop() { + loop_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrDoWhile) + } + + static { + defaultInstance = new IrDoWhile(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrDoWhile) + } + + public interface IrEnumConstructorCallOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall} + */ + public static final class IrEnumConstructorCall extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall) + IrEnumConstructorCallOrBuilder { + // Use IrEnumConstructorCall.newBuilder() to construct. + private IrEnumConstructorCall(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrEnumConstructorCall(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrEnumConstructorCall defaultInstance; + public static IrEnumConstructorCall getDefaultInstance() { + return defaultInstance; + } + + public IrEnumConstructorCall getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrEnumConstructorCall( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(memberAccess_); + memberAccess_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrEnumConstructorCall parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrEnumConstructorCall(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasMemberAccess()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getMemberAccess().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, memberAccess_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, memberAccess_); + } + 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.KotlinIr.IrEnumConstructorCall 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.KotlinIr.IrEnumConstructorCall 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.KotlinIr.IrEnumConstructorCall parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall 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.KotlinIr.IrEnumConstructorCall parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall 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.KotlinIr.IrEnumConstructorCall parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall 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.KotlinIr.IrEnumConstructorCall parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall 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.KotlinIr.IrEnumConstructorCall prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCallOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.memberAccess_ = memberAccess_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasMemberAccess()) { + mergeMemberAccess(other.getMemberAccess()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasMemberAccess()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getMemberAccess().isInitialized()) { + + 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.KotlinIr.IrEnumConstructorCall parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + memberAccess_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.MemberAccessCommon member_access = 2; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall) + } + + static { + defaultInstance = new IrEnumConstructorCall(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall) + } + + public interface IrGetClassOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrGetClass) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + boolean hasArgument(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetClass} + */ + public static final class IrGetClass extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetClass) + IrGetClassOrBuilder { + // Use IrGetClass.newBuilder() to construct. + private IrGetClass(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrGetClass(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrGetClass defaultInstance; + public static IrGetClass getDefaultInstance() { + return defaultInstance; + } + + public IrGetClass getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrGetClass( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = argument_.toBuilder(); + } + argument_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(argument_); + argument_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrGetClass parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrGetClass(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int ARGUMENT_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression argument_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public boolean hasArgument() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument() { + return argument_; + } + + private void initFields() { + argument_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasArgument()) { + memoizedIsInitialized = 0; + return false; + } + if (!getArgument().isInitialized()) { + 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.writeMessage(1, argument_); + } + 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 + .computeMessageSize(1, argument_); + } + 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.KotlinIr.IrGetClass 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.KotlinIr.IrGetClass 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.KotlinIr.IrGetClass parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass 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.KotlinIr.IrGetClass parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass 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.KotlinIr.IrGetClass parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass 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.KotlinIr.IrGetClass parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass 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.KotlinIr.IrGetClass prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetClass} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetClass) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClassOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + argument_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.argument_ = argument_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.getDefaultInstance()) return this; + if (other.hasArgument()) { + mergeArgument(other.getArgument()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasArgument()) { + + return false; + } + if (!getArgument().isInitialized()) { + + 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.KotlinIr.IrGetClass parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression argument_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public boolean hasArgument() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument() { + return argument_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder setArgument(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + argument_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder setArgument( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + argument_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder mergeArgument(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + argument_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + argument_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(argument_).mergeFrom(value).buildPartial(); + } else { + argument_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder clearArgument() { + argument_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetClass) + } + + static { + defaultInstance = new IrGetClass(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetClass) + } + + public interface IrGetEnumValueOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue} + */ + public static final class IrGetEnumValue extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue) + IrGetEnumValueOrBuilder { + // Use IrGetEnumValue.newBuilder() to construct. + private IrGetEnumValue(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrGetEnumValue(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrGetEnumValue defaultInstance; + public static IrGetEnumValue getDefaultInstance() { + return defaultInstance; + } + + public IrGetEnumValue getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrGetEnumValue( + 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); + 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 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrGetEnumValue parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrGetEnumValue(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + 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.writeMessage(2, symbol_); + } + 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 + .computeMessageSize(2, symbol_); + } + 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.KotlinIr.IrGetEnumValue 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.KotlinIr.IrGetEnumValue 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.KotlinIr.IrGetEnumValue parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue 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.KotlinIr.IrGetEnumValue parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue 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.KotlinIr.IrGetEnumValue parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue 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.KotlinIr.IrGetEnumValue parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue 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.KotlinIr.IrGetEnumValue prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValueOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + 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.KotlinIr.IrGetEnumValue parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue) + } + + static { + defaultInstance = new IrGetEnumValue(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue) + } + + public interface FieldAccessCommonOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + boolean hasSuper(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSuper(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + boolean hasReceiver(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getReceiver(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon} + */ + public static final class FieldAccessCommon extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon) + FieldAccessCommonOrBuilder { + // Use FieldAccessCommon.newBuilder() to construct. + private FieldAccessCommon(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private FieldAccessCommon(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final FieldAccessCommon defaultInstance; + public static FieldAccessCommon getDefaultInstance() { + return defaultInstance; + } + + public FieldAccessCommon getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private FieldAccessCommon( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = super_.toBuilder(); + } + super_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(super_); + super_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = receiver_.toBuilder(); + } + receiver_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(receiver_); + receiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + 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 FieldAccessCommon parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new FieldAccessCommon(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int SUPER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol super_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + public boolean hasSuper() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSuper() { + return super_; + } + + public static final int RECEIVER_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression receiver_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getReceiver() { + return receiver_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasSuper()) { + if (!getSuper().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasReceiver()) { + if (!getReceiver().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, super_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, receiver_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, super_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, receiver_); + } + 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.KotlinIr.FieldAccessCommon 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.KotlinIr.FieldAccessCommon 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.KotlinIr.FieldAccessCommon parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon 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.KotlinIr.FieldAccessCommon parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon 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.KotlinIr.FieldAccessCommon parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon 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.KotlinIr.FieldAccessCommon parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon 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.KotlinIr.FieldAccessCommon prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommonOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.super_ = super_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.receiver_ = receiver_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasSuper()) { + mergeSuper(other.getSuper()); + } + if (other.hasReceiver()) { + mergeReceiver(other.getReceiver()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (hasSuper()) { + if (!getSuper().isInitialized()) { + + return false; + } + } + if (hasReceiver()) { + if (!getReceiver().isInitialized()) { + + 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.KotlinIr.FieldAccessCommon parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + public boolean hasSuper() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSuper() { + return super_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + public Builder setSuper(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + super_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + public Builder setSuper( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + super_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + public Builder mergeSuper(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + super_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + super_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(super_).mergeFrom(value).buildPartial(); + } else { + super_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 2; + */ + public Builder clearSuper() { + super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getReceiver() { + return receiver_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + public Builder setReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + receiver_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + public Builder setReceiver( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + receiver_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + public Builder mergeReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + receiver_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + receiver_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(receiver_).mergeFrom(value).buildPartial(); + } else { + receiver_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 3; + */ + public Builder clearReceiver() { + receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon) + } + + static { + defaultInstance = new FieldAccessCommon(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon) + } + + public interface IrGetFieldOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrGetField) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + boolean hasFieldAccess(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon getFieldAccess(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetField} + */ + public static final class IrGetField extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetField) + IrGetFieldOrBuilder { + // Use IrGetField.newBuilder() to construct. + private IrGetField(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrGetField(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrGetField defaultInstance; + public static IrGetField getDefaultInstance() { + return defaultInstance; + } + + public IrGetField getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrGetField( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = fieldAccess_.toBuilder(); + } + fieldAccess_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(fieldAccess_); + fieldAccess_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrGetField parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrGetField(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int FIELD_ACCESS_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon fieldAccess_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public boolean hasFieldAccess() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon getFieldAccess() { + return fieldAccess_; + } + + private void initFields() { + fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasFieldAccess()) { + memoizedIsInitialized = 0; + return false; + } + if (!getFieldAccess().isInitialized()) { + 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.writeMessage(1, fieldAccess_); + } + 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 + .computeMessageSize(1, fieldAccess_); + } + 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.KotlinIr.IrGetField 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.KotlinIr.IrGetField 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.KotlinIr.IrGetField parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField 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.KotlinIr.IrGetField parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField 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.KotlinIr.IrGetField parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField 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.KotlinIr.IrGetField parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField 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.KotlinIr.IrGetField prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetField} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetField) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetFieldOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.fieldAccess_ = fieldAccess_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.getDefaultInstance()) return this; + if (other.hasFieldAccess()) { + mergeFieldAccess(other.getFieldAccess()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasFieldAccess()) { + + return false; + } + if (!getFieldAccess().isInitialized()) { + + 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.KotlinIr.IrGetField parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public boolean hasFieldAccess() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon getFieldAccess() { + return fieldAccess_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public Builder setFieldAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + fieldAccess_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public Builder setFieldAccess( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.Builder builderForValue) { + fieldAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public Builder mergeFieldAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + fieldAccess_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance()) { + fieldAccess_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.newBuilder(fieldAccess_).mergeFrom(value).buildPartial(); + } else { + fieldAccess_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public Builder clearFieldAccess() { + fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetField) + } + + static { + defaultInstance = new IrGetField(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetField) + } + + public interface IrGetValueOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrGetValue) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetValue} + */ + public static final class IrGetValue extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetValue) + IrGetValueOrBuilder { + // Use IrGetValue.newBuilder() to construct. + private IrGetValue(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrGetValue(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrGetValue defaultInstance; + public static IrGetValue getDefaultInstance() { + return defaultInstance; + } + + public IrGetValue getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrGetValue( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrGetValue parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrGetValue(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + 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.writeMessage(1, symbol_); + } + 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 + .computeMessageSize(1, symbol_); + } + 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.KotlinIr.IrGetValue 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.KotlinIr.IrGetValue 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.KotlinIr.IrGetValue parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue 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.KotlinIr.IrGetValue parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue 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.KotlinIr.IrGetValue parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue 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.KotlinIr.IrGetValue parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue 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.KotlinIr.IrGetValue prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetValue} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetValue) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValueOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + 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.KotlinIr.IrGetValue parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetValue) + } + + static { + defaultInstance = new IrGetValue(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetValue) + } + + public interface IrGetObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrGetObject) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetObject} + */ + public static final class IrGetObject extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetObject) + IrGetObjectOrBuilder { + // Use IrGetObject.newBuilder() to construct. + private IrGetObject(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrGetObject(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrGetObject defaultInstance; + public static IrGetObject getDefaultInstance() { + return defaultInstance; + } + + public IrGetObject getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrGetObject( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrGetObject parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrGetObject(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + 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.writeMessage(1, symbol_); + } + 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 + .computeMessageSize(1, symbol_); + } + 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.KotlinIr.IrGetObject 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.KotlinIr.IrGetObject 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.KotlinIr.IrGetObject parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject 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.KotlinIr.IrGetObject parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject 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.KotlinIr.IrGetObject parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject 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.KotlinIr.IrGetObject parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject 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.KotlinIr.IrGetObject prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetObject} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrGetObject) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObjectOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + 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.KotlinIr.IrGetObject parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetObject) + } + + static { + defaultInstance = new IrGetObject(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetObject) + } + + public interface IrInstanceInitializerCallOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall} + */ + public static final class IrInstanceInitializerCall extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall) + IrInstanceInitializerCallOrBuilder { + // Use IrInstanceInitializerCall.newBuilder() to construct. + private IrInstanceInitializerCall(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrInstanceInitializerCall(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrInstanceInitializerCall defaultInstance; + public static IrInstanceInitializerCall getDefaultInstance() { + return defaultInstance; + } + + public IrInstanceInitializerCall getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrInstanceInitializerCall( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrInstanceInitializerCall parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrInstanceInitializerCall(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + 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.writeMessage(1, symbol_); + } + 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 + .computeMessageSize(1, symbol_); + } + 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.KotlinIr.IrInstanceInitializerCall 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.KotlinIr.IrInstanceInitializerCall 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.KotlinIr.IrInstanceInitializerCall parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall 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.KotlinIr.IrInstanceInitializerCall parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall 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.KotlinIr.IrInstanceInitializerCall parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall 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.KotlinIr.IrInstanceInitializerCall parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall 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.KotlinIr.IrInstanceInitializerCall prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCallOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + 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.KotlinIr.IrInstanceInitializerCall parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall) + } + + static { + defaultInstance = new IrInstanceInitializerCall(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall) + } + + public interface LoopOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.Loop) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 loop_id = 1; + */ + boolean hasLoopId(); + /** + * required int32 loop_id = 1; + */ + int getLoopId(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + boolean hasCondition(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getCondition(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + boolean hasLabel(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getLabel(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + boolean hasBody(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getBody(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Loop} + */ + public static final class Loop extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.Loop) + LoopOrBuilder { + // Use Loop.newBuilder() to construct. + private Loop(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Loop(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final Loop defaultInstance; + public static Loop getDefaultInstance() { + return defaultInstance; + } + + public Loop getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private Loop( + 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); + 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; + loopId_ = input.readInt32(); + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = condition_.toBuilder(); + } + condition_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(condition_); + condition_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = label_.toBuilder(); + } + label_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(label_); + label_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = body_.toBuilder(); + } + body_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(body_); + body_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + 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 Loop parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new Loop(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int LOOP_ID_FIELD_NUMBER = 1; + private int loopId_; + /** + * required int32 loop_id = 1; + */ + public boolean hasLoopId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 loop_id = 1; + */ + public int getLoopId() { + return loopId_; + } + + public static final int CONDITION_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression condition_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + public boolean hasCondition() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getCondition() { + return condition_; + } + + public static final int LABEL_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String label_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getLabel() { + return label_; + } + + public static final int BODY_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression body_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getBody() { + return body_; + } + + private void initFields() { + loopId_ = 0; + condition_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasLoopId()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasCondition()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCondition().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasLabel()) { + if (!getLabel().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasBody()) { + if (!getBody().isInitialized()) { + 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, loopId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, condition_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, label_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, body_); + } + 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, loopId_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, condition_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, label_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, body_); + } + 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.KotlinIr.Loop 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.KotlinIr.Loop 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.KotlinIr.Loop parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop 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.KotlinIr.Loop parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop 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.KotlinIr.Loop parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop 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.KotlinIr.Loop parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop 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.KotlinIr.Loop prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Loop} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.Loop) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.LoopOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + loopId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + condition_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.loopId_ = loopId_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.condition_ = condition_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.label_ = label_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.body_ = body_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance()) return this; + if (other.hasLoopId()) { + setLoopId(other.getLoopId()); + } + if (other.hasCondition()) { + mergeCondition(other.getCondition()); + } + if (other.hasLabel()) { + mergeLabel(other.getLabel()); + } + if (other.hasBody()) { + mergeBody(other.getBody()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasLoopId()) { + + return false; + } + if (!hasCondition()) { + + return false; + } + if (!getCondition().isInitialized()) { + + return false; + } + if (hasLabel()) { + if (!getLabel().isInitialized()) { + + return false; + } + } + if (hasBody()) { + if (!getBody().isInitialized()) { + + 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.KotlinIr.Loop parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int loopId_ ; + /** + * required int32 loop_id = 1; + */ + public boolean hasLoopId() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 loop_id = 1; + */ + public int getLoopId() { + return loopId_; + } + /** + * required int32 loop_id = 1; + */ + public Builder setLoopId(int value) { + bitField0_ |= 0x00000001; + loopId_ = value; + + return this; + } + /** + * required int32 loop_id = 1; + */ + public Builder clearLoopId() { + bitField0_ = (bitField0_ & ~0x00000001); + loopId_ = 0; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression condition_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + public boolean hasCondition() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getCondition() { + return condition_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + public Builder setCondition(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + condition_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + public Builder setCondition( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + condition_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + public Builder mergeCondition(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + condition_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + condition_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(condition_).mergeFrom(value).buildPartial(); + } else { + condition_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 2; + */ + public Builder clearCondition() { + condition_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getLabel() { + return label_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + public Builder setLabel(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + label_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + public Builder setLabel( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + label_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + public Builder mergeLabel(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + label_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + label_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(label_).mergeFrom(value).buildPartial(); + } else { + label_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.String label = 3; + */ + public Builder clearLabel() { + label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getBody() { + return body_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + public Builder setBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + body_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + public Builder setBody( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + body_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + public Builder mergeBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + body_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + body_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(body_).mergeFrom(value).buildPartial(); + } else { + body_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; + */ + public Builder clearBody() { + body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.Loop) + } + + static { + defaultInstance = new Loop(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.Loop) + } + + public interface IrReturnOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrReturn) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + boolean hasReturnTarget(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getReturnTarget(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + boolean hasValue(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrReturn} + */ + public static final class IrReturn extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrReturn) + IrReturnOrBuilder { + // Use IrReturn.newBuilder() to construct. + private IrReturn(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrReturn(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrReturn defaultInstance; + public static IrReturn getDefaultInstance() { + return defaultInstance; + } + + public IrReturn getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrReturn( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = returnTarget_.toBuilder(); + } + returnTarget_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(returnTarget_); + returnTarget_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(value_); + value_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrReturn parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrReturn(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int RETURN_TARGET_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol returnTarget_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + public boolean hasReturnTarget() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getReturnTarget() { + return returnTarget_; + } + + public static final int VALUE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue() { + return value_; + } + + private void initFields() { + returnTarget_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasReturnTarget()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasValue()) { + memoizedIsInitialized = 0; + return false; + } + if (!getReturnTarget().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getValue().isInitialized()) { + 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.writeMessage(1, returnTarget_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, value_); + } + 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 + .computeMessageSize(1, returnTarget_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, value_); + } + 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.KotlinIr.IrReturn 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.KotlinIr.IrReturn 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.KotlinIr.IrReturn parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn 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.KotlinIr.IrReturn parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn 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.KotlinIr.IrReturn parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn 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.KotlinIr.IrReturn parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn 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.KotlinIr.IrReturn prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrReturn} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrReturn) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturnOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + returnTarget_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.returnTarget_ = returnTarget_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.value_ = value_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.getDefaultInstance()) return this; + if (other.hasReturnTarget()) { + mergeReturnTarget(other.getReturnTarget()); + } + if (other.hasValue()) { + mergeValue(other.getValue()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasReturnTarget()) { + + return false; + } + if (!hasValue()) { + + return false; + } + if (!getReturnTarget().isInitialized()) { + + return false; + } + if (!getValue().isInitialized()) { + + 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.KotlinIr.IrReturn parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol returnTarget_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + public boolean hasReturnTarget() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getReturnTarget() { + return returnTarget_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + public Builder setReturnTarget(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + returnTarget_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + public Builder setReturnTarget( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + returnTarget_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + public Builder mergeReturnTarget(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + returnTarget_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + returnTarget_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(returnTarget_).mergeFrom(value).buildPartial(); + } else { + returnTarget_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol return_target = 1; + */ + public Builder clearReturnTarget() { + returnTarget_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue() { + return value_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder setValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder setValue( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + value_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder mergeValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + value_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + value_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder clearValue() { + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrReturn) + } + + static { + defaultInstance = new IrReturn(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrReturn) + } + + public interface IrSetFieldOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrSetField) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + boolean hasFieldAccess(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon getFieldAccess(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + boolean hasValue(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSetField} + */ + public static final class IrSetField extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrSetField) + IrSetFieldOrBuilder { + // Use IrSetField.newBuilder() to construct. + private IrSetField(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrSetField(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrSetField defaultInstance; + public static IrSetField getDefaultInstance() { + return defaultInstance; + } + + public IrSetField getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrSetField( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = fieldAccess_.toBuilder(); + } + fieldAccess_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(fieldAccess_); + fieldAccess_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(value_); + value_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrSetField parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrSetField(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int FIELD_ACCESS_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon fieldAccess_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public boolean hasFieldAccess() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon getFieldAccess() { + return fieldAccess_; + } + + public static final int VALUE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue() { + return value_; + } + + private void initFields() { + fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasFieldAccess()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasValue()) { + memoizedIsInitialized = 0; + return false; + } + if (!getFieldAccess().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getValue().isInitialized()) { + 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.writeMessage(1, fieldAccess_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, value_); + } + 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 + .computeMessageSize(1, fieldAccess_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, value_); + } + 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.KotlinIr.IrSetField 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.KotlinIr.IrSetField 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.KotlinIr.IrSetField parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField 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.KotlinIr.IrSetField parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField 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.KotlinIr.IrSetField parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField 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.KotlinIr.IrSetField parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField 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.KotlinIr.IrSetField prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSetField} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrSetField) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetFieldOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.fieldAccess_ = fieldAccess_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.value_ = value_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.getDefaultInstance()) return this; + if (other.hasFieldAccess()) { + mergeFieldAccess(other.getFieldAccess()); + } + if (other.hasValue()) { + mergeValue(other.getValue()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasFieldAccess()) { + + return false; + } + if (!hasValue()) { + + return false; + } + if (!getFieldAccess().isInitialized()) { + + return false; + } + if (!getValue().isInitialized()) { + + 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.KotlinIr.IrSetField parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public boolean hasFieldAccess() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon getFieldAccess() { + return fieldAccess_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public Builder setFieldAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + fieldAccess_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public Builder setFieldAccess( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.Builder builderForValue) { + fieldAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public Builder mergeFieldAccess(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + fieldAccess_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance()) { + fieldAccess_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.newBuilder(fieldAccess_).mergeFrom(value).buildPartial(); + } else { + fieldAccess_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; + */ + public Builder clearFieldAccess() { + fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue() { + return value_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder setValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder setValue( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + value_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder mergeValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + value_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + value_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder clearValue() { + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSetField) + } + + static { + defaultInstance = new IrSetField(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrSetField) + } + + public interface IrSetVariableOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrSetVariable) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + boolean hasValue(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSetVariable} + */ + public static final class IrSetVariable extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrSetVariable) + IrSetVariableOrBuilder { + // Use IrSetVariable.newBuilder() to construct. + private IrSetVariable(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrSetVariable(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrSetVariable defaultInstance; + public static IrSetVariable getDefaultInstance() { + return defaultInstance; + } + + public IrSetVariable getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrSetVariable( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(value_); + value_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrSetVariable parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrSetVariable(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int VALUE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue() { + return value_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasValue()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getValue().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, value_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, value_); + } + 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.KotlinIr.IrSetVariable 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.KotlinIr.IrSetVariable 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.KotlinIr.IrSetVariable parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable 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.KotlinIr.IrSetVariable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable 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.KotlinIr.IrSetVariable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable 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.KotlinIr.IrSetVariable parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable 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.KotlinIr.IrSetVariable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSetVariable} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrSetVariable) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariableOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.value_ = value_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasValue()) { + mergeValue(other.getValue()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasValue()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getValue().isInitialized()) { + + 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.KotlinIr.IrSetVariable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue() { + return value_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder setValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder setValue( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + value_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder mergeValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + value_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + value_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; + */ + public Builder clearValue() { + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSetVariable) + } + + static { + defaultInstance = new IrSetVariable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrSetVariable) + } + + public interface IrSpreadElementOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + boolean hasExpression(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + boolean hasCoordinates(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement} + */ + public static final class IrSpreadElement extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement) + IrSpreadElementOrBuilder { + // Use IrSpreadElement.newBuilder() to construct. + private IrSpreadElement(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrSpreadElement(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrSpreadElement defaultInstance; + public static IrSpreadElement getDefaultInstance() { + return defaultInstance; + } + + public IrSpreadElement getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrSpreadElement( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = expression_.toBuilder(); + } + expression_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(expression_); + expression_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = coordinates_.toBuilder(); + } + coordinates_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(coordinates_); + coordinates_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrSpreadElement parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrSpreadElement(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int EXPRESSION_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression expression_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public boolean hasExpression() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression() { + return expression_; + } + + public static final int COORDINATES_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates coordinates_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates() { + return coordinates_; + } + + private void initFields() { + expression_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasExpression()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasCoordinates()) { + memoizedIsInitialized = 0; + return false; + } + if (!getExpression().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCoordinates().isInitialized()) { + 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.writeMessage(1, expression_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, coordinates_); + } + 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 + .computeMessageSize(1, expression_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, coordinates_); + } + 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.KotlinIr.IrSpreadElement 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.KotlinIr.IrSpreadElement 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.KotlinIr.IrSpreadElement parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement 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.KotlinIr.IrSpreadElement parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement 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.KotlinIr.IrSpreadElement parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement 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.KotlinIr.IrSpreadElement parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement 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.KotlinIr.IrSpreadElement prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElementOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + expression_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.expression_ = expression_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.coordinates_ = coordinates_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.getDefaultInstance()) return this; + if (other.hasExpression()) { + mergeExpression(other.getExpression()); + } + if (other.hasCoordinates()) { + mergeCoordinates(other.getCoordinates()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasExpression()) { + + return false; + } + if (!hasCoordinates()) { + + return false; + } + if (!getExpression().isInitialized()) { + + return false; + } + if (!getCoordinates().isInitialized()) { + + 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.KotlinIr.IrSpreadElement parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression expression_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public boolean hasExpression() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression() { + return expression_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder setExpression(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + expression_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder setExpression( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + expression_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder mergeExpression(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + expression_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + expression_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(expression_).mergeFrom(value).buildPartial(); + } else { + expression_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder clearExpression() { + expression_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates() { + return coordinates_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public Builder setCoordinates(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates value) { + if (value == null) { + throw new NullPointerException(); + } + coordinates_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public Builder setCoordinates( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.Builder builderForValue) { + coordinates_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public Builder mergeCoordinates(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + coordinates_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance()) { + coordinates_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.newBuilder(coordinates_).mergeFrom(value).buildPartial(); + } else { + coordinates_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public Builder clearCoordinates() { + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement) + } + + static { + defaultInstance = new IrSpreadElement(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement) + } + + public interface IrStringConcatOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrStringConcat) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + java.util.List + getArgumentList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + int getArgumentCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrStringConcat} + */ + public static final class IrStringConcat extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrStringConcat) + IrStringConcatOrBuilder { + // Use IrStringConcat.newBuilder() to construct. + private IrStringConcat(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrStringConcat(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrStringConcat defaultInstance; + public static IrStringConcat getDefaultInstance() { + return defaultInstance; + } + + public IrStringConcat getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrStringConcat( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + argument_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + argument_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + argument_ = java.util.Collections.unmodifiableList(argument_); + } + 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 IrStringConcat parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrStringConcat(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int ARGUMENT_FIELD_NUMBER = 1; + private java.util.List argument_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public java.util.List getArgumentList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public java.util.List + getArgumentOrBuilderList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpressionOrBuilder getArgumentOrBuilder( + int index) { + return argument_.get(index); + } + + private void initFields() { + argument_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getArgumentCount(); i++) { + if (!getArgument(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < argument_.size(); i++) { + output.writeMessage(1, argument_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < argument_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, argument_.get(i)); + } + 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.KotlinIr.IrStringConcat 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.KotlinIr.IrStringConcat 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.KotlinIr.IrStringConcat parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat 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.KotlinIr.IrStringConcat parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat 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.KotlinIr.IrStringConcat parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat 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.KotlinIr.IrStringConcat parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat 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.KotlinIr.IrStringConcat prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrStringConcat} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrStringConcat) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcatOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + argument_ = java.util.Collections.unmodifiableList(argument_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.argument_ = argument_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.getDefaultInstance()) return this; + if (!other.argument_.isEmpty()) { + if (argument_.isEmpty()) { + argument_ = other.argument_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureArgumentIsMutable(); + argument_.addAll(other.argument_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getArgumentCount(); i++) { + if (!getArgument(i).isInitialized()) { + + 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.KotlinIr.IrStringConcat parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List argument_ = + java.util.Collections.emptyList(); + private void ensureArgumentIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + argument_ = new java.util.ArrayList(argument_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public java.util.List getArgumentList() { + return java.util.Collections.unmodifiableList(argument_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder addArgument(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder addArgument( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder addAllArgument( + java.lang.Iterable values) { + ensureArgumentIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, argument_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder clearArgument() { + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 1; + */ + public Builder removeArgument(int index) { + ensureArgumentIsMutable(); + argument_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrStringConcat) + } + + static { + defaultInstance = new IrStringConcat(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrStringConcat) + } + + public interface IrThrowOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrThrow) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + boolean hasValue(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrThrow} + */ + public static final class IrThrow extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrThrow) + IrThrowOrBuilder { + // Use IrThrow.newBuilder() to construct. + private IrThrow(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrThrow(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrThrow defaultInstance; + public static IrThrow getDefaultInstance() { + return defaultInstance; + } + + public IrThrow getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrThrow( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(value_); + value_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrThrow parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrThrow(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int VALUE_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue() { + return value_; + } + + private void initFields() { + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasValue()) { + memoizedIsInitialized = 0; + return false; + } + if (!getValue().isInitialized()) { + 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.writeMessage(1, value_); + } + 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 + .computeMessageSize(1, value_); + } + 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.KotlinIr.IrThrow 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.KotlinIr.IrThrow 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.KotlinIr.IrThrow parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow 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.KotlinIr.IrThrow parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow 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.KotlinIr.IrThrow parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow 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.KotlinIr.IrThrow parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow 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.KotlinIr.IrThrow prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrThrow} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrThrow) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrowOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.value_ = value_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.getDefaultInstance()) return this; + if (other.hasValue()) { + mergeValue(other.getValue()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasValue()) { + + return false; + } + if (!getValue().isInitialized()) { + + 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.KotlinIr.IrThrow parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue() { + return value_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + public Builder setValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + public Builder setValue( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + value_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + public Builder mergeValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + value_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + value_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 1; + */ + public Builder clearValue() { + value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrThrow) + } + + static { + defaultInstance = new IrThrow(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrThrow) + } + + public interface IrTryOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrTry) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + boolean hasResult(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getResult(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + java.util.List + getCatchList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getCatch(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + int getCatchCount(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + boolean hasFinally(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getFinally(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTry} + */ + public static final class IrTry extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrTry) + IrTryOrBuilder { + // Use IrTry.newBuilder() to construct. + private IrTry(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrTry(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrTry defaultInstance; + public static IrTry getDefaultInstance() { + return defaultInstance; + } + + public IrTry getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrTry( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = result_.toBuilder(); + } + result_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(result_); + result_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + catch_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + catch_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.PARSER, extensionRegistry)); + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = finally_.toBuilder(); + } + finally_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(finally_); + finally_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 { + if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + catch_ = java.util.Collections.unmodifiableList(catch_); + } + 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 IrTry parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrTry(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int RESULT_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression result_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getResult() { + return result_; + } + + public static final int CATCH_FIELD_NUMBER = 2; + private java.util.List catch_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public java.util.List getCatchList() { + return catch_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public java.util.List + getCatchOrBuilderList() { + return catch_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public int getCatchCount() { + return catch_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getCatch(int index) { + return catch_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrBuilder getCatchOrBuilder( + int index) { + return catch_.get(index); + } + + public static final int FINALLY_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression finally_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + public boolean hasFinally() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getFinally() { + return finally_; + } + + private void initFields() { + result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + catch_ = java.util.Collections.emptyList(); + finally_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasResult()) { + memoizedIsInitialized = 0; + return false; + } + if (!getResult().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getCatchCount(); i++) { + if (!getCatch(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasFinally()) { + if (!getFinally().isInitialized()) { + 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.writeMessage(1, result_); + } + for (int i = 0; i < catch_.size(); i++) { + output.writeMessage(2, catch_.get(i)); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(3, finally_); + } + 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 + .computeMessageSize(1, result_); + } + for (int i = 0; i < catch_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, catch_.get(i)); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, finally_); + } + 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.KotlinIr.IrTry 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.KotlinIr.IrTry 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.KotlinIr.IrTry parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry 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.KotlinIr.IrTry parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry 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.KotlinIr.IrTry parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry 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.KotlinIr.IrTry parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry 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.KotlinIr.IrTry prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTry} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrTry) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTryOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + catch_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + finally_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.result_ = result_; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + catch_ = java.util.Collections.unmodifiableList(catch_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.catch_ = catch_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000002; + } + result.finally_ = finally_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.getDefaultInstance()) return this; + if (other.hasResult()) { + mergeResult(other.getResult()); + } + if (!other.catch_.isEmpty()) { + if (catch_.isEmpty()) { + catch_ = other.catch_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureCatchIsMutable(); + catch_.addAll(other.catch_); + } + + } + if (other.hasFinally()) { + mergeFinally(other.getFinally()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasResult()) { + + return false; + } + if (!getResult().isInitialized()) { + + return false; + } + for (int i = 0; i < getCatchCount(); i++) { + if (!getCatch(i).isInitialized()) { + + return false; + } + } + if (hasFinally()) { + if (!getFinally().isInitialized()) { + + 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.KotlinIr.IrTry parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getResult() { + return result_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + public Builder setResult(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + result_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + public Builder setResult( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + result_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + public Builder mergeResult(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + result_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + result_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(result_).mergeFrom(value).buildPartial(); + } else { + result_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 1; + */ + public Builder clearResult() { + result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private java.util.List catch_ = + java.util.Collections.emptyList(); + private void ensureCatchIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + catch_ = new java.util.ArrayList(catch_); + bitField0_ |= 0x00000002; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public java.util.List getCatchList() { + return java.util.Collections.unmodifiableList(catch_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public int getCatchCount() { + return catch_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getCatch(int index) { + return catch_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public Builder setCatch( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureCatchIsMutable(); + catch_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public Builder setCatch( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureCatchIsMutable(); + catch_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public Builder addCatch(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureCatchIsMutable(); + catch_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public Builder addCatch( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureCatchIsMutable(); + catch_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public Builder addCatch( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureCatchIsMutable(); + catch_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public Builder addCatch( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureCatchIsMutable(); + catch_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public Builder addAllCatch( + java.lang.Iterable values) { + ensureCatchIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, catch_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public Builder clearCatch() { + catch_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement catch = 2; + */ + public Builder removeCatch(int index) { + ensureCatchIsMutable(); + catch_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression finally_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + public boolean hasFinally() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getFinally() { + return finally_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + public Builder setFinally(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + finally_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + public Builder setFinally( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + finally_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + public Builder mergeFinally(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + finally_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + finally_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(finally_).mergeFrom(value).buildPartial(); + } else { + finally_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression finally = 3; + */ + public Builder clearFinally() { + finally_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrTry) + } + + static { + defaultInstance = new IrTry(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrTry) + } + + public interface IrTypeOpOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrTypeOp) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator operator = 1; + */ + boolean hasOperator(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator operator = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator getOperator(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + boolean hasOperand(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getOperand(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + boolean hasArgument(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeOp} + */ + public static final class IrTypeOp extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeOp) + IrTypeOpOrBuilder { + // Use IrTypeOp.newBuilder() to construct. + private IrTypeOp(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrTypeOp(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrTypeOp defaultInstance; + public static IrTypeOp getDefaultInstance() { + return defaultInstance; + } + + public IrTypeOp getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrTypeOp( + 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); + 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: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + operator_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = operand_.toBuilder(); + } + operand_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(operand_); + operand_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = argument_.toBuilder(); + } + argument_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(argument_); + argument_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + 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 IrTypeOp parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrTypeOp(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int OPERATOR_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator operator_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator operator = 1; + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator operator = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator getOperator() { + return operator_; + } + + public static final int OPERAND_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex operand_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + public boolean hasOperand() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getOperand() { + return operand_; + } + + public static final int ARGUMENT_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression argument_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public boolean hasArgument() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument() { + return argument_; + } + + private void initFields() { + operator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator.CAST; + operand_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + argument_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasOperator()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasOperand()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasArgument()) { + memoizedIsInitialized = 0; + return false; + } + if (!getOperand().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getArgument().isInitialized()) { + 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.writeEnum(1, operator_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, operand_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, argument_); + } + 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 + .computeEnumSize(1, operator_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, operand_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, argument_); + } + 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.KotlinIr.IrTypeOp 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.KotlinIr.IrTypeOp 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.KotlinIr.IrTypeOp parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp 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.KotlinIr.IrTypeOp parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp 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.KotlinIr.IrTypeOp parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp 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.KotlinIr.IrTypeOp parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp 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.KotlinIr.IrTypeOp prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeOp} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeOp) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOpOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + operator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator.CAST; + bitField0_ = (bitField0_ & ~0x00000001); + operand_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + argument_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.operator_ = operator_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.operand_ = operand_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.argument_ = argument_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.getDefaultInstance()) return this; + if (other.hasOperator()) { + setOperator(other.getOperator()); + } + if (other.hasOperand()) { + mergeOperand(other.getOperand()); + } + if (other.hasArgument()) { + mergeArgument(other.getArgument()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasOperator()) { + + return false; + } + if (!hasOperand()) { + + return false; + } + if (!hasArgument()) { + + return false; + } + if (!getOperand().isInitialized()) { + + return false; + } + if (!getArgument().isInitialized()) { + + 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.KotlinIr.IrTypeOp parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator operator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator.CAST; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator operator = 1; + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator operator = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator getOperator() { + return operator_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator operator = 1; + */ + public Builder setOperator(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + operator_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeOperator operator = 1; + */ + public Builder clearOperator() { + bitField0_ = (bitField0_ & ~0x00000001); + operator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOperator.CAST; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex operand_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + public boolean hasOperand() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getOperand() { + return operand_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + public Builder setOperand(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + operand_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + public Builder setOperand( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + operand_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + public Builder mergeOperand(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + operand_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + operand_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(operand_).mergeFrom(value).buildPartial(); + } else { + operand_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex operand = 2; + */ + public Builder clearOperand() { + operand_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression argument_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public boolean hasArgument() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument() { + return argument_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder setArgument(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + argument_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder setArgument( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + argument_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder mergeArgument(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + argument_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + argument_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(argument_).mergeFrom(value).buildPartial(); + } else { + argument_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder clearArgument() { + argument_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeOp) + } + + static { + defaultInstance = new IrTypeOp(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeOp) + } + + public interface IrVarargOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrVararg) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + boolean hasElementType(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getElementType(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + java.util.List + getElementList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement getElement(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + int getElementCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrVararg} + */ + public static final class IrVararg extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrVararg) + IrVarargOrBuilder { + // Use IrVararg.newBuilder() to construct. + private IrVararg(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrVararg(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrVararg defaultInstance; + public static IrVararg getDefaultInstance() { + return defaultInstance; + } + + public IrVararg getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrVararg( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = elementType_.toBuilder(); + } + elementType_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(elementType_); + elementType_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + element_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + element_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + element_ = java.util.Collections.unmodifiableList(element_); + } + 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 IrVararg parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrVararg(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int ELEMENT_TYPE_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex elementType_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + public boolean hasElementType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getElementType() { + return elementType_; + } + + public static final int ELEMENT_FIELD_NUMBER = 2; + private java.util.List element_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public java.util.List getElementList() { + return element_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public java.util.List + getElementOrBuilderList() { + return element_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public int getElementCount() { + return element_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement getElement(int index) { + return element_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElementOrBuilder getElementOrBuilder( + int index) { + return element_.get(index); + } + + private void initFields() { + elementType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + element_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasElementType()) { + memoizedIsInitialized = 0; + return false; + } + if (!getElementType().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getElementCount(); i++) { + if (!getElement(i).isInitialized()) { + 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.writeMessage(1, elementType_); + } + for (int i = 0; i < element_.size(); i++) { + output.writeMessage(2, element_.get(i)); + } + 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 + .computeMessageSize(1, elementType_); + } + for (int i = 0; i < element_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, element_.get(i)); + } + 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.KotlinIr.IrVararg 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.KotlinIr.IrVararg 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.KotlinIr.IrVararg parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg 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.KotlinIr.IrVararg parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg 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.KotlinIr.IrVararg parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg 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.KotlinIr.IrVararg parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg 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.KotlinIr.IrVararg prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrVararg} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrVararg) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + elementType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + element_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.elementType_ = elementType_; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + element_ = java.util.Collections.unmodifiableList(element_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.element_ = element_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.getDefaultInstance()) return this; + if (other.hasElementType()) { + mergeElementType(other.getElementType()); + } + if (!other.element_.isEmpty()) { + if (element_.isEmpty()) { + element_ = other.element_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureElementIsMutable(); + element_.addAll(other.element_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasElementType()) { + + return false; + } + if (!getElementType().isInitialized()) { + + return false; + } + for (int i = 0; i < getElementCount(); i++) { + if (!getElement(i).isInitialized()) { + + 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.KotlinIr.IrVararg parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex elementType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + public boolean hasElementType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getElementType() { + return elementType_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + public Builder setElementType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + elementType_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + public Builder setElementType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + elementType_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + public Builder mergeElementType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + elementType_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + elementType_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(elementType_).mergeFrom(value).buildPartial(); + } else { + elementType_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex element_type = 1; + */ + public Builder clearElementType() { + elementType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private java.util.List element_ = + java.util.Collections.emptyList(); + private void ensureElementIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + element_ = new java.util.ArrayList(element_); + bitField0_ |= 0x00000002; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public java.util.List getElementList() { + return java.util.Collections.unmodifiableList(element_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public int getElementCount() { + return element_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement getElement(int index) { + return element_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public Builder setElement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureElementIsMutable(); + element_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public Builder setElement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement.Builder builderForValue) { + ensureElementIsMutable(); + element_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public Builder addElement(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureElementIsMutable(); + element_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public Builder addElement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureElementIsMutable(); + element_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public Builder addElement( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement.Builder builderForValue) { + ensureElementIsMutable(); + element_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public Builder addElement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement.Builder builderForValue) { + ensureElementIsMutable(); + element_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public Builder addAllElement( + java.lang.Iterable values) { + ensureElementIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, element_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public Builder clearElement() { + element_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrVarargElement element = 2; + */ + public Builder removeElement(int index) { + ensureElementIsMutable(); + element_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrVararg) + } + + static { + defaultInstance = new IrVararg(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrVararg) + } + + public interface IrVarargElementOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrVarargElement) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + boolean hasExpression(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + boolean hasSpreadElement(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement getSpreadElement(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrVarargElement} + */ + public static final class IrVarargElement extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrVarargElement) + IrVarargElementOrBuilder { + // Use IrVarargElement.newBuilder() to construct. + private IrVarargElement(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrVarargElement(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrVarargElement defaultInstance; + public static IrVarargElement getDefaultInstance() { + return defaultInstance; + } + + public IrVarargElement getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrVarargElement( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (varargElementCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) varargElement_).toBuilder(); + } + varargElement_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) varargElement_); + varargElement_ = subBuilder.buildPartial(); + } + varargElementCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.Builder subBuilder = null; + if (varargElementCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement) varargElement_).toBuilder(); + } + varargElement_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement) varargElement_); + varargElement_ = subBuilder.buildPartial(); + } + varargElementCase_ = 2; + 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 IrVarargElement parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrVarargElement(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + private int varargElementCase_ = 0; + private java.lang.Object varargElement_; + public enum VarargElementCase + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + EXPRESSION(1), + SPREAD_ELEMENT(2), + VARARGELEMENT_NOT_SET(0); + private int value = 0; + private VarargElementCase(int value) { + this.value = value; + } + public static VarargElementCase valueOf(int value) { + switch (value) { + case 1: return EXPRESSION; + case 2: return SPREAD_ELEMENT; + case 0: return VARARGELEMENT_NOT_SET; + default: throw new java.lang.IllegalArgumentException( + "Value is undefined for this oneof enum."); + } + } + public int getNumber() { + return this.value; + } + }; + + public VarargElementCase + getVarargElementCase() { + return VarargElementCase.valueOf( + varargElementCase_); + } + + public static final int EXPRESSION_FIELD_NUMBER = 1; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public boolean hasExpression() { + return varargElementCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression() { + if (varargElementCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) varargElement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + + public static final int SPREAD_ELEMENT_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + public boolean hasSpreadElement() { + return varargElementCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement getSpreadElement() { + if (varargElementCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement) varargElement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.getDefaultInstance(); + } + + private void initFields() { + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (hasExpression()) { + if (!getExpression().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasSpreadElement()) { + if (!getSpreadElement().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (varargElementCase_ == 1) { + output.writeMessage(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) varargElement_); + } + if (varargElementCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement) varargElement_); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (varargElementCase_ == 1) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) varargElement_); + } + if (varargElementCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement) varargElement_); + } + 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.KotlinIr.IrVarargElement 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.KotlinIr.IrVarargElement 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.KotlinIr.IrVarargElement parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement 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.KotlinIr.IrVarargElement parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement 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.KotlinIr.IrVarargElement parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement 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.KotlinIr.IrVarargElement parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement 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.KotlinIr.IrVarargElement prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrVarargElement} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrVarargElement) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElementOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + varargElementCase_ = 0; + varargElement_ = null; + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (varargElementCase_ == 1) { + result.varargElement_ = varargElement_; + } + if (varargElementCase_ == 2) { + result.varargElement_ = varargElement_; + } + result.bitField0_ = to_bitField0_; + result.varargElementCase_ = varargElementCase_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement.getDefaultInstance()) return this; + switch (other.getVarargElementCase()) { + case EXPRESSION: { + mergeExpression(other.getExpression()); + break; + } + case SPREAD_ELEMENT: { + mergeSpreadElement(other.getSpreadElement()); + break; + } + case VARARGELEMENT_NOT_SET: { + break; + } + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (hasExpression()) { + if (!getExpression().isInitialized()) { + + return false; + } + } + if (hasSpreadElement()) { + if (!getSpreadElement().isInitialized()) { + + 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.KotlinIr.IrVarargElement parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVarargElement) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int varargElementCase_ = 0; + private java.lang.Object varargElement_; + public VarargElementCase + getVarargElementCase() { + return VarargElementCase.valueOf( + varargElementCase_); + } + + public Builder clearVarargElement() { + varargElementCase_ = 0; + varargElement_ = null; + return this; + } + + private int bitField0_; + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public boolean hasExpression() { + return varargElementCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression() { + if (varargElementCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) varargElement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder setExpression(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + varargElement_ = value; + + varargElementCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder setExpression( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + varargElement_ = builderForValue.build(); + + varargElementCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder mergeExpression(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (varargElementCase_ == 1 && + varargElement_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + varargElement_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) varargElement_) + .mergeFrom(value).buildPartial(); + } else { + varargElement_ = value; + } + + varargElementCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder clearExpression() { + if (varargElementCase_ == 1) { + varargElementCase_ = 0; + varargElement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + public boolean hasSpreadElement() { + return varargElementCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement getSpreadElement() { + if (varargElementCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement) varargElement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + public Builder setSpreadElement(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement value) { + if (value == null) { + throw new NullPointerException(); + } + varargElement_ = value; + + varargElementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + public Builder setSpreadElement( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.Builder builderForValue) { + varargElement_ = builderForValue.build(); + + varargElementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + public Builder mergeSpreadElement(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement value) { + if (varargElementCase_ == 2 && + varargElement_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.getDefaultInstance()) { + varargElement_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSpreadElement) varargElement_) + .mergeFrom(value).buildPartial(); + } else { + varargElement_ = value; + } + + varargElementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSpreadElement spread_element = 2; + */ + public Builder clearSpreadElement() { + if (varargElementCase_ == 2) { + varargElementCase_ = 0; + varargElement_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrVarargElement) + } + + static { + defaultInstance = new IrVarargElement(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrVarargElement) + } + + public interface IrWhenOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrWhen) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + java.util.List + getBranchList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getBranch(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + int getBranchCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrWhen} + */ + public static final class IrWhen extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrWhen) + IrWhenOrBuilder { + // Use IrWhen.newBuilder() to construct. + private IrWhen(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrWhen(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrWhen defaultInstance; + public static IrWhen getDefaultInstance() { + return defaultInstance; + } + + public IrWhen getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrWhen( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + branch_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + branch_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + branch_ = java.util.Collections.unmodifiableList(branch_); + } + 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 IrWhen parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrWhen(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int BRANCH_FIELD_NUMBER = 1; + private java.util.List branch_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public java.util.List getBranchList() { + return branch_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public java.util.List + getBranchOrBuilderList() { + return branch_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public int getBranchCount() { + return branch_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getBranch(int index) { + return branch_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrBuilder getBranchOrBuilder( + int index) { + return branch_.get(index); + } + + private void initFields() { + branch_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getBranchCount(); i++) { + if (!getBranch(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < branch_.size(); i++) { + output.writeMessage(1, branch_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < branch_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, branch_.get(i)); + } + 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.KotlinIr.IrWhen 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.KotlinIr.IrWhen 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.KotlinIr.IrWhen parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen 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.KotlinIr.IrWhen parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen 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.KotlinIr.IrWhen parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen 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.KotlinIr.IrWhen parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen 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.KotlinIr.IrWhen prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrWhen} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrWhen) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhenOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + branch_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + branch_ = java.util.Collections.unmodifiableList(branch_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.branch_ = branch_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.getDefaultInstance()) return this; + if (!other.branch_.isEmpty()) { + if (branch_.isEmpty()) { + branch_ = other.branch_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureBranchIsMutable(); + branch_.addAll(other.branch_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getBranchCount(); i++) { + if (!getBranch(i).isInitialized()) { + + 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.KotlinIr.IrWhen parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List branch_ = + java.util.Collections.emptyList(); + private void ensureBranchIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + branch_ = new java.util.ArrayList(branch_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public java.util.List getBranchList() { + return java.util.Collections.unmodifiableList(branch_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public int getBranchCount() { + return branch_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getBranch(int index) { + return branch_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public Builder setBranch( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureBranchIsMutable(); + branch_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public Builder setBranch( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureBranchIsMutable(); + branch_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public Builder addBranch(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureBranchIsMutable(); + branch_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public Builder addBranch( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureBranchIsMutable(); + branch_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public Builder addBranch( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureBranchIsMutable(); + branch_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public Builder addBranch( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureBranchIsMutable(); + branch_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public Builder addAllBranch( + java.lang.Iterable values) { + ensureBranchIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, branch_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public Builder clearBranch() { + branch_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; + */ + public Builder removeBranch(int index) { + ensureBranchIsMutable(); + branch_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrWhen) + } + + static { + defaultInstance = new IrWhen(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrWhen) + } + + public interface IrWhileOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrWhile) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + boolean hasLoop(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop getLoop(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrWhile} + */ + public static final class IrWhile extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrWhile) + IrWhileOrBuilder { + // Use IrWhile.newBuilder() to construct. + private IrWhile(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrWhile(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrWhile defaultInstance; + public static IrWhile getDefaultInstance() { + return defaultInstance; + } + + public IrWhile getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrWhile( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = loop_.toBuilder(); + } + loop_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(loop_); + loop_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 IrWhile parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrWhile(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int LOOP_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop loop_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public boolean hasLoop() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop getLoop() { + return loop_; + } + + private void initFields() { + loop_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasLoop()) { + memoizedIsInitialized = 0; + return false; + } + if (!getLoop().isInitialized()) { + 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.writeMessage(1, loop_); + } + 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 + .computeMessageSize(1, loop_); + } + 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.KotlinIr.IrWhile 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.KotlinIr.IrWhile 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.KotlinIr.IrWhile parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile 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.KotlinIr.IrWhile parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile 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.KotlinIr.IrWhile parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile 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.KotlinIr.IrWhile parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile 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.KotlinIr.IrWhile prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrWhile} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrWhile) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhileOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + loop_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.loop_ = loop_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.getDefaultInstance()) return this; + if (other.hasLoop()) { + mergeLoop(other.getLoop()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasLoop()) { + + return false; + } + if (!getLoop().isInitialized()) { + + 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.KotlinIr.IrWhile parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop loop_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public boolean hasLoop() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop getLoop() { + return loop_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public Builder setLoop(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop value) { + if (value == null) { + throw new NullPointerException(); + } + loop_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public Builder setLoop( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.Builder builderForValue) { + loop_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public Builder mergeLoop(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + loop_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance()) { + loop_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.newBuilder(loop_).mergeFrom(value).buildPartial(); + } else { + loop_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Loop loop = 1; + */ + public Builder clearLoop() { + loop_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Loop.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrWhile) + } + + static { + defaultInstance = new IrWhile(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrWhile) + } + + public interface IrDynamicMemberExpressionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + boolean hasMemberName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getMemberName(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + boolean hasReceiver(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getReceiver(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression} + */ + public static final class IrDynamicMemberExpression extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression) + IrDynamicMemberExpressionOrBuilder { + // Use IrDynamicMemberExpression.newBuilder() to construct. + private IrDynamicMemberExpression(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDynamicMemberExpression(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDynamicMemberExpression defaultInstance; + public static IrDynamicMemberExpression getDefaultInstance() { + return defaultInstance; + } + + public IrDynamicMemberExpression getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDynamicMemberExpression( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = memberName_.toBuilder(); + } + memberName_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(memberName_); + memberName_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = receiver_.toBuilder(); + } + receiver_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(receiver_); + receiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrDynamicMemberExpression parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDynamicMemberExpression(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int MEMBERNAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String memberName_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + public boolean hasMemberName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getMemberName() { + return memberName_; + } + + public static final int RECEIVER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression receiver_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getReceiver() { + return receiver_; + } + + private void initFields() { + memberName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasMemberName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasReceiver()) { + memoizedIsInitialized = 0; + return false; + } + if (!getMemberName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getReceiver().isInitialized()) { + 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.writeMessage(1, memberName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, receiver_); + } + 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 + .computeMessageSize(1, memberName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, receiver_); + } + 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.KotlinIr.IrDynamicMemberExpression 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.KotlinIr.IrDynamicMemberExpression 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.KotlinIr.IrDynamicMemberExpression parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression 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.KotlinIr.IrDynamicMemberExpression parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression 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.KotlinIr.IrDynamicMemberExpression parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression 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.KotlinIr.IrDynamicMemberExpression parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression 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.KotlinIr.IrDynamicMemberExpression prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpressionOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + memberName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.memberName_ = memberName_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.receiver_ = receiver_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.getDefaultInstance()) return this; + if (other.hasMemberName()) { + mergeMemberName(other.getMemberName()); + } + if (other.hasReceiver()) { + mergeReceiver(other.getReceiver()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasMemberName()) { + + return false; + } + if (!hasReceiver()) { + + return false; + } + if (!getMemberName().isInitialized()) { + + return false; + } + if (!getReceiver().isInitialized()) { + + 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.KotlinIr.IrDynamicMemberExpression parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String memberName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + public boolean hasMemberName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String getMemberName() { + return memberName_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + public Builder setMemberName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (value == null) { + throw new NullPointerException(); + } + memberName_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + public Builder setMemberName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.Builder builderForValue) { + memberName_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + public Builder mergeMemberName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + memberName_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance()) { + memberName_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.newBuilder(memberName_).mergeFrom(value).buildPartial(); + } else { + memberName_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.String memberName = 1; + */ + public Builder clearMemberName() { + memberName_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getReceiver() { + return receiver_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public Builder setReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + receiver_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public Builder setReceiver( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + receiver_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public Builder mergeReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + receiver_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + receiver_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(receiver_).mergeFrom(value).buildPartial(); + } else { + receiver_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public Builder clearReceiver() { + receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression) + } + + static { + defaultInstance = new IrDynamicMemberExpression(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression) + } + + public interface IrDynamicOperatorExpressionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + boolean hasOperator(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator getOperator(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + boolean hasReceiver(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getReceiver(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + java.util.List + getArgumentList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + int getArgumentCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression} + */ + public static final class IrDynamicOperatorExpression extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression) + IrDynamicOperatorExpressionOrBuilder { + // Use IrDynamicOperatorExpression.newBuilder() to construct. + private IrDynamicOperatorExpression(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDynamicOperatorExpression(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDynamicOperatorExpression defaultInstance; + public static IrDynamicOperatorExpression getDefaultInstance() { + return defaultInstance; + } + + public IrDynamicOperatorExpression getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDynamicOperatorExpression( + 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); + 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: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + operator_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = receiver_.toBuilder(); + } + receiver_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(receiver_); + receiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + argument_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + argument_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + argument_ = java.util.Collections.unmodifiableList(argument_); + } + 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 IrDynamicOperatorExpression parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDynamicOperatorExpression(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator} + */ + public enum IrDynamicOperator + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * UNARY_PLUS = 1; + */ + UNARY_PLUS(0, 1), + /** + * UNARY_MINUS = 2; + */ + UNARY_MINUS(1, 2), + /** + * EXCL = 3; + */ + EXCL(2, 3), + /** + * PREFIX_INCREMENT = 4; + */ + PREFIX_INCREMENT(3, 4), + /** + * POSTFIX_INCREMENT = 5; + */ + POSTFIX_INCREMENT(4, 5), + /** + * PREFIX_DECREMENT = 6; + */ + PREFIX_DECREMENT(5, 6), + /** + * POSTFIX_DECREMENT = 7; + */ + POSTFIX_DECREMENT(6, 7), + /** + * BINARY_PLUS = 8; + */ + BINARY_PLUS(7, 8), + /** + * BINARY_MINUS = 9; + */ + BINARY_MINUS(8, 9), + /** + * MUL = 10; + */ + MUL(9, 10), + /** + * DIV = 11; + */ + DIV(10, 11), + /** + * MOD = 12; + */ + MOD(11, 12), + /** + * GT = 13; + */ + GT(12, 13), + /** + * LT = 14; + */ + LT(13, 14), + /** + * GE = 15; + */ + GE(14, 15), + /** + * LE = 16; + */ + LE(15, 16), + /** + * EQEQ = 17; + */ + EQEQ(16, 17), + /** + * EXCLEQ = 18; + */ + EXCLEQ(17, 18), + /** + * EQEQEQ = 19; + */ + EQEQEQ(18, 19), + /** + * EXCLEQEQ = 20; + */ + EXCLEQEQ(19, 20), + /** + * ANDAND = 21; + */ + ANDAND(20, 21), + /** + * OROR = 22; + */ + OROR(21, 22), + /** + * EQ = 23; + */ + EQ(22, 23), + /** + * PLUSEQ = 24; + */ + PLUSEQ(23, 24), + /** + * MINUSEQ = 25; + */ + MINUSEQ(24, 25), + /** + * MULEQ = 26; + */ + MULEQ(25, 26), + /** + * DIVEQ = 27; + */ + DIVEQ(26, 27), + /** + * MODEQ = 28; + */ + MODEQ(27, 28), + /** + * ARRAY_ACCESS = 29; + */ + ARRAY_ACCESS(28, 29), + /** + * INVOKE = 30; + */ + INVOKE(29, 30), + ; + + /** + * UNARY_PLUS = 1; + */ + public static final int UNARY_PLUS_VALUE = 1; + /** + * UNARY_MINUS = 2; + */ + public static final int UNARY_MINUS_VALUE = 2; + /** + * EXCL = 3; + */ + public static final int EXCL_VALUE = 3; + /** + * PREFIX_INCREMENT = 4; + */ + public static final int PREFIX_INCREMENT_VALUE = 4; + /** + * POSTFIX_INCREMENT = 5; + */ + public static final int POSTFIX_INCREMENT_VALUE = 5; + /** + * PREFIX_DECREMENT = 6; + */ + public static final int PREFIX_DECREMENT_VALUE = 6; + /** + * POSTFIX_DECREMENT = 7; + */ + public static final int POSTFIX_DECREMENT_VALUE = 7; + /** + * BINARY_PLUS = 8; + */ + public static final int BINARY_PLUS_VALUE = 8; + /** + * BINARY_MINUS = 9; + */ + public static final int BINARY_MINUS_VALUE = 9; + /** + * MUL = 10; + */ + public static final int MUL_VALUE = 10; + /** + * DIV = 11; + */ + public static final int DIV_VALUE = 11; + /** + * MOD = 12; + */ + public static final int MOD_VALUE = 12; + /** + * GT = 13; + */ + public static final int GT_VALUE = 13; + /** + * LT = 14; + */ + public static final int LT_VALUE = 14; + /** + * GE = 15; + */ + public static final int GE_VALUE = 15; + /** + * LE = 16; + */ + public static final int LE_VALUE = 16; + /** + * EQEQ = 17; + */ + public static final int EQEQ_VALUE = 17; + /** + * EXCLEQ = 18; + */ + public static final int EXCLEQ_VALUE = 18; + /** + * EQEQEQ = 19; + */ + public static final int EQEQEQ_VALUE = 19; + /** + * EXCLEQEQ = 20; + */ + public static final int EXCLEQEQ_VALUE = 20; + /** + * ANDAND = 21; + */ + public static final int ANDAND_VALUE = 21; + /** + * OROR = 22; + */ + public static final int OROR_VALUE = 22; + /** + * EQ = 23; + */ + public static final int EQ_VALUE = 23; + /** + * PLUSEQ = 24; + */ + public static final int PLUSEQ_VALUE = 24; + /** + * MINUSEQ = 25; + */ + public static final int MINUSEQ_VALUE = 25; + /** + * MULEQ = 26; + */ + public static final int MULEQ_VALUE = 26; + /** + * DIVEQ = 27; + */ + public static final int DIVEQ_VALUE = 27; + /** + * MODEQ = 28; + */ + public static final int MODEQ_VALUE = 28; + /** + * ARRAY_ACCESS = 29; + */ + public static final int ARRAY_ACCESS_VALUE = 29; + /** + * INVOKE = 30; + */ + public static final int INVOKE_VALUE = 30; + + + public final int getNumber() { return value; } + + public static IrDynamicOperator valueOf(int value) { + switch (value) { + case 1: return UNARY_PLUS; + case 2: return UNARY_MINUS; + case 3: return EXCL; + case 4: return PREFIX_INCREMENT; + case 5: return POSTFIX_INCREMENT; + case 6: return PREFIX_DECREMENT; + case 7: return POSTFIX_DECREMENT; + case 8: return BINARY_PLUS; + case 9: return BINARY_MINUS; + case 10: return MUL; + case 11: return DIV; + case 12: return MOD; + case 13: return GT; + case 14: return LT; + case 15: return GE; + case 16: return LE; + case 17: return EQEQ; + case 18: return EXCLEQ; + case 19: return EQEQEQ; + case 20: return EXCLEQEQ; + case 21: return ANDAND; + case 22: return OROR; + case 23: return EQ; + case 24: return PLUSEQ; + case 25: return MINUSEQ; + case 26: return MULEQ; + case 27: return DIVEQ; + case 28: return MODEQ; + case 29: return ARRAY_ACCESS; + case 30: return INVOKE; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public IrDynamicOperator findValueByNumber(int number) { + return IrDynamicOperator.valueOf(number); + } + }; + + private final int value; + + private IrDynamicOperator(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator) + } + + private int bitField0_; + public static final int OPERATOR_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator operator_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator getOperator() { + return operator_; + } + + public static final int RECEIVER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression receiver_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getReceiver() { + return receiver_; + } + + public static final int ARGUMENT_FIELD_NUMBER = 3; + private java.util.List argument_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public java.util.List getArgumentList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public java.util.List + getArgumentOrBuilderList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpressionOrBuilder getArgumentOrBuilder( + int index) { + return argument_.get(index); + } + + private void initFields() { + operator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS; + receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + argument_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasOperator()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasReceiver()) { + memoizedIsInitialized = 0; + return false; + } + if (!getReceiver().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getArgumentCount(); i++) { + if (!getArgument(i).isInitialized()) { + 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.writeEnum(1, operator_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, receiver_); + } + for (int i = 0; i < argument_.size(); i++) { + output.writeMessage(3, argument_.get(i)); + } + 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 + .computeEnumSize(1, operator_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, receiver_); + } + for (int i = 0; i < argument_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, argument_.get(i)); + } + 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.KotlinIr.IrDynamicOperatorExpression 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.KotlinIr.IrDynamicOperatorExpression 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.KotlinIr.IrDynamicOperatorExpression parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression 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.KotlinIr.IrDynamicOperatorExpression parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression 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.KotlinIr.IrDynamicOperatorExpression parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression 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.KotlinIr.IrDynamicOperatorExpression parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression 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.KotlinIr.IrDynamicOperatorExpression prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpressionOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + operator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS; + bitField0_ = (bitField0_ & ~0x00000001); + receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.operator_ = operator_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.receiver_ = receiver_; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + argument_ = java.util.Collections.unmodifiableList(argument_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.argument_ = argument_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.getDefaultInstance()) return this; + if (other.hasOperator()) { + setOperator(other.getOperator()); + } + if (other.hasReceiver()) { + mergeReceiver(other.getReceiver()); + } + if (!other.argument_.isEmpty()) { + if (argument_.isEmpty()) { + argument_ = other.argument_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureArgumentIsMutable(); + argument_.addAll(other.argument_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasOperator()) { + + return false; + } + if (!hasReceiver()) { + + return false; + } + if (!getReceiver().isInitialized()) { + + return false; + } + for (int i = 0; i < getArgumentCount(); i++) { + if (!getArgument(i).isInitialized()) { + + 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.KotlinIr.IrDynamicOperatorExpression parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator operator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator getOperator() { + return operator_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public Builder setOperator(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + operator_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public Builder clearOperator() { + bitField0_ = (bitField0_ & ~0x00000001); + operator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getReceiver() { + return receiver_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public Builder setReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + receiver_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public Builder setReceiver( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + receiver_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public Builder mergeReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + receiver_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + receiver_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(receiver_).mergeFrom(value).buildPartial(); + } else { + receiver_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression receiver = 2; + */ + public Builder clearReceiver() { + receiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private java.util.List argument_ = + java.util.Collections.emptyList(); + private void ensureArgumentIsMutable() { + if (!((bitField0_ & 0x00000004) == 0x00000004)) { + argument_ = new java.util.ArrayList(argument_); + bitField0_ |= 0x00000004; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public java.util.List getArgumentList() { + return java.util.Collections.unmodifiableList(argument_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder addArgument(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder addArgument( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder addAllArgument( + java.lang.Iterable values) { + ensureArgumentIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, argument_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder clearArgument() { + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrExpression argument = 3; + */ + public Builder removeArgument(int index) { + ensureArgumentIsMutable(); + argument_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression) + } + + static { + defaultInstance = new IrDynamicOperatorExpression(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression) + } + + public interface IrOperationOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrOperation) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + boolean hasBlock(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock getBlock(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + boolean hasBreak(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak getBreak(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + boolean hasCall(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall getCall(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + boolean hasClassReference(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference getClassReference(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + boolean hasComposite(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite getComposite(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + boolean hasConst(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst getConst(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + boolean hasContinue(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue getContinue(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + boolean hasDelegatingConstructorCall(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall getDelegatingConstructorCall(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + boolean hasDoWhile(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile getDoWhile(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + boolean hasEnumConstructorCall(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall getEnumConstructorCall(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + boolean hasFunctionReference(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference getFunctionReference(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + boolean hasGetClass(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass getGetClass(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + boolean hasGetEnumValue(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue getGetEnumValue(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + boolean hasGetField(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField getGetField(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + boolean hasGetObject(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject getGetObject(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + boolean hasGetValue(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue getGetValue(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + boolean hasInstanceInitializerCall(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall getInstanceInitializerCall(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + boolean hasPropertyReference(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference getPropertyReference(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + boolean hasReturn(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn getReturn(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + boolean hasSetField(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField getSetField(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + boolean hasSetVariable(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable getSetVariable(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + boolean hasStringConcat(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat getStringConcat(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + boolean hasThrow(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow getThrow(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + boolean hasTry(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry getTry(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + boolean hasTypeOp(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp getTypeOp(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + boolean hasVararg(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg getVararg(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + boolean hasWhen(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen getWhen(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + boolean hasWhile(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile getWhile(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + boolean hasDynamicMember(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression getDynamicMember(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + boolean hasDynamicOperator(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression getDynamicOperator(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrOperation} + * + * 
+   * TODO: we need an extension mechanism to accomodate new
+   * IR operators in upcoming releases.
+   *
+ */ + public static final class IrOperation extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrOperation) + IrOperationOrBuilder { + // Use IrOperation.newBuilder() to construct. + private IrOperation(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrOperation(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrOperation defaultInstance; + public static IrOperation getDefaultInstance() { + return defaultInstance; + } + + public IrOperation getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrOperation( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.Builder subBuilder = null; + if (operationCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.Builder subBuilder = null; + if (operationCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 2; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Builder subBuilder = null; + if (operationCase_ == 3) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 3; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.Builder subBuilder = null; + if (operationCase_ == 4) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 4; + break; + } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.Builder subBuilder = null; + if (operationCase_ == 5) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 5; + break; + } + case 50: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.Builder subBuilder = null; + if (operationCase_ == 6) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 6; + break; + } + case 58: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.Builder subBuilder = null; + if (operationCase_ == 7) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 7; + break; + } + case 66: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.Builder subBuilder = null; + if (operationCase_ == 8) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 8; + break; + } + case 74: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.Builder subBuilder = null; + if (operationCase_ == 9) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 9; + break; + } + case 82: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.Builder subBuilder = null; + if (operationCase_ == 10) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 10; + break; + } + case 90: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.Builder subBuilder = null; + if (operationCase_ == 11) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 11; + break; + } + case 98: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.Builder subBuilder = null; + if (operationCase_ == 12) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 12; + break; + } + case 106: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.Builder subBuilder = null; + if (operationCase_ == 13) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 13; + break; + } + case 114: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.Builder subBuilder = null; + if (operationCase_ == 14) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 14; + break; + } + case 122: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.Builder subBuilder = null; + if (operationCase_ == 15) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 15; + break; + } + case 130: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.Builder subBuilder = null; + if (operationCase_ == 16) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 16; + break; + } + case 138: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.Builder subBuilder = null; + if (operationCase_ == 17) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 17; + break; + } + case 146: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.Builder subBuilder = null; + if (operationCase_ == 18) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 18; + break; + } + case 154: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.Builder subBuilder = null; + if (operationCase_ == 19) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 19; + break; + } + case 162: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.Builder subBuilder = null; + if (operationCase_ == 20) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 20; + break; + } + case 170: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.Builder subBuilder = null; + if (operationCase_ == 21) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 21; + break; + } + case 178: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.Builder subBuilder = null; + if (operationCase_ == 22) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 22; + break; + } + case 186: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.Builder subBuilder = null; + if (operationCase_ == 23) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 23; + break; + } + case 194: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.Builder subBuilder = null; + if (operationCase_ == 24) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 24; + break; + } + case 202: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.Builder subBuilder = null; + if (operationCase_ == 25) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 25; + break; + } + case 210: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.Builder subBuilder = null; + if (operationCase_ == 26) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 26; + break; + } + case 218: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.Builder subBuilder = null; + if (operationCase_ == 27) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 27; + break; + } + case 226: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.Builder subBuilder = null; + if (operationCase_ == 28) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 28; + break; + } + case 234: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.Builder subBuilder = null; + if (operationCase_ == 29) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 29; + break; + } + case 242: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.Builder subBuilder = null; + if (operationCase_ == 30) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 30; + 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 IrOperation parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrOperation(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + private int operationCase_ = 0; + private java.lang.Object operation_; + public enum OperationCase + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + BLOCK(1), + BREAK(2), + CALL(3), + CLASS_REFERENCE(4), + COMPOSITE(5), + CONST(6), + CONTINUE(7), + DELEGATING_CONSTRUCTOR_CALL(8), + DO_WHILE(9), + ENUM_CONSTRUCTOR_CALL(10), + FUNCTION_REFERENCE(11), + GET_CLASS(12), + GET_ENUM_VALUE(13), + GET_FIELD(14), + GET_OBJECT(15), + GET_VALUE(16), + INSTANCE_INITIALIZER_CALL(17), + PROPERTY_REFERENCE(18), + RETURN(19), + SET_FIELD(20), + SET_VARIABLE(21), + STRING_CONCAT(22), + THROW(23), + TRY(24), + TYPE_OP(25), + VARARG(26), + WHEN(27), + WHILE(28), + DYNAMIC_MEMBER(29), + DYNAMIC_OPERATOR(30), + OPERATION_NOT_SET(0); + private int value = 0; + private OperationCase(int value) { + this.value = value; + } + public static OperationCase valueOf(int value) { + switch (value) { + case 1: return BLOCK; + case 2: return BREAK; + case 3: return CALL; + case 4: return CLASS_REFERENCE; + case 5: return COMPOSITE; + case 6: return CONST; + case 7: return CONTINUE; + case 8: return DELEGATING_CONSTRUCTOR_CALL; + case 9: return DO_WHILE; + case 10: return ENUM_CONSTRUCTOR_CALL; + case 11: return FUNCTION_REFERENCE; + case 12: return GET_CLASS; + case 13: return GET_ENUM_VALUE; + case 14: return GET_FIELD; + case 15: return GET_OBJECT; + case 16: return GET_VALUE; + case 17: return INSTANCE_INITIALIZER_CALL; + case 18: return PROPERTY_REFERENCE; + case 19: return RETURN; + case 20: return SET_FIELD; + case 21: return SET_VARIABLE; + case 22: return STRING_CONCAT; + case 23: return THROW; + case 24: return TRY; + case 25: return TYPE_OP; + case 26: return VARARG; + case 27: return WHEN; + case 28: return WHILE; + case 29: return DYNAMIC_MEMBER; + case 30: return DYNAMIC_OPERATOR; + case 0: return OPERATION_NOT_SET; + default: throw new java.lang.IllegalArgumentException( + "Value is undefined for this oneof enum."); + } + } + public int getNumber() { + return this.value; + } + }; + + public OperationCase + getOperationCase() { + return OperationCase.valueOf( + operationCase_); + } + + public static final int BLOCK_FIELD_NUMBER = 1; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + public boolean hasBlock() { + return operationCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock getBlock() { + if (operationCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.getDefaultInstance(); + } + + public static final int BREAK_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + public boolean hasBreak() { + return operationCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak getBreak() { + if (operationCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.getDefaultInstance(); + } + + public static final int CALL_FIELD_NUMBER = 3; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + public boolean hasCall() { + return operationCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall getCall() { + if (operationCase_ == 3) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.getDefaultInstance(); + } + + public static final int CLASS_REFERENCE_FIELD_NUMBER = 4; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + public boolean hasClassReference() { + return operationCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference getClassReference() { + if (operationCase_ == 4) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.getDefaultInstance(); + } + + public static final int COMPOSITE_FIELD_NUMBER = 5; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + public boolean hasComposite() { + return operationCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite getComposite() { + if (operationCase_ == 5) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.getDefaultInstance(); + } + + public static final int CONST_FIELD_NUMBER = 6; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + public boolean hasConst() { + return operationCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst getConst() { + if (operationCase_ == 6) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.getDefaultInstance(); + } + + public static final int CONTINUE_FIELD_NUMBER = 7; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + public boolean hasContinue() { + return operationCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue getContinue() { + if (operationCase_ == 7) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.getDefaultInstance(); + } + + public static final int DELEGATING_CONSTRUCTOR_CALL_FIELD_NUMBER = 8; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public boolean hasDelegatingConstructorCall() { + return operationCase_ == 8; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall getDelegatingConstructorCall() { + if (operationCase_ == 8) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.getDefaultInstance(); + } + + public static final int DO_WHILE_FIELD_NUMBER = 9; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + public boolean hasDoWhile() { + return operationCase_ == 9; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile getDoWhile() { + if (operationCase_ == 9) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.getDefaultInstance(); + } + + public static final int ENUM_CONSTRUCTOR_CALL_FIELD_NUMBER = 10; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + public boolean hasEnumConstructorCall() { + return operationCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall getEnumConstructorCall() { + if (operationCase_ == 10) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.getDefaultInstance(); + } + + public static final int FUNCTION_REFERENCE_FIELD_NUMBER = 11; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + public boolean hasFunctionReference() { + return operationCase_ == 11; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference getFunctionReference() { + if (operationCase_ == 11) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.getDefaultInstance(); + } + + public static final int GET_CLASS_FIELD_NUMBER = 12; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + public boolean hasGetClass() { + return operationCase_ == 12; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass getGetClass() { + if (operationCase_ == 12) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.getDefaultInstance(); + } + + public static final int GET_ENUM_VALUE_FIELD_NUMBER = 13; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + public boolean hasGetEnumValue() { + return operationCase_ == 13; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue getGetEnumValue() { + if (operationCase_ == 13) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.getDefaultInstance(); + } + + public static final int GET_FIELD_FIELD_NUMBER = 14; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + public boolean hasGetField() { + return operationCase_ == 14; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField getGetField() { + if (operationCase_ == 14) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.getDefaultInstance(); + } + + public static final int GET_OBJECT_FIELD_NUMBER = 15; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + public boolean hasGetObject() { + return operationCase_ == 15; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject getGetObject() { + if (operationCase_ == 15) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.getDefaultInstance(); + } + + public static final int GET_VALUE_FIELD_NUMBER = 16; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + public boolean hasGetValue() { + return operationCase_ == 16; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue getGetValue() { + if (operationCase_ == 16) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.getDefaultInstance(); + } + + public static final int INSTANCE_INITIALIZER_CALL_FIELD_NUMBER = 17; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public boolean hasInstanceInitializerCall() { + return operationCase_ == 17; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall getInstanceInitializerCall() { + if (operationCase_ == 17) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.getDefaultInstance(); + } + + public static final int PROPERTY_REFERENCE_FIELD_NUMBER = 18; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + public boolean hasPropertyReference() { + return operationCase_ == 18; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference getPropertyReference() { + if (operationCase_ == 18) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.getDefaultInstance(); + } + + public static final int RETURN_FIELD_NUMBER = 19; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + public boolean hasReturn() { + return operationCase_ == 19; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn getReturn() { + if (operationCase_ == 19) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.getDefaultInstance(); + } + + public static final int SET_FIELD_FIELD_NUMBER = 20; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + public boolean hasSetField() { + return operationCase_ == 20; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField getSetField() { + if (operationCase_ == 20) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.getDefaultInstance(); + } + + public static final int SET_VARIABLE_FIELD_NUMBER = 21; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + public boolean hasSetVariable() { + return operationCase_ == 21; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable getSetVariable() { + if (operationCase_ == 21) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.getDefaultInstance(); + } + + public static final int STRING_CONCAT_FIELD_NUMBER = 22; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + public boolean hasStringConcat() { + return operationCase_ == 22; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat getStringConcat() { + if (operationCase_ == 22) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.getDefaultInstance(); + } + + public static final int THROW_FIELD_NUMBER = 23; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + public boolean hasThrow() { + return operationCase_ == 23; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow getThrow() { + if (operationCase_ == 23) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.getDefaultInstance(); + } + + public static final int TRY_FIELD_NUMBER = 24; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + public boolean hasTry() { + return operationCase_ == 24; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry getTry() { + if (operationCase_ == 24) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.getDefaultInstance(); + } + + public static final int TYPE_OP_FIELD_NUMBER = 25; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + public boolean hasTypeOp() { + return operationCase_ == 25; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp getTypeOp() { + if (operationCase_ == 25) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.getDefaultInstance(); + } + + public static final int VARARG_FIELD_NUMBER = 26; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + public boolean hasVararg() { + return operationCase_ == 26; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg getVararg() { + if (operationCase_ == 26) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.getDefaultInstance(); + } + + public static final int WHEN_FIELD_NUMBER = 27; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + public boolean hasWhen() { + return operationCase_ == 27; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen getWhen() { + if (operationCase_ == 27) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.getDefaultInstance(); + } + + public static final int WHILE_FIELD_NUMBER = 28; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + public boolean hasWhile() { + return operationCase_ == 28; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile getWhile() { + if (operationCase_ == 28) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.getDefaultInstance(); + } + + public static final int DYNAMIC_MEMBER_FIELD_NUMBER = 29; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + public boolean hasDynamicMember() { + return operationCase_ == 29; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression getDynamicMember() { + if (operationCase_ == 29) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.getDefaultInstance(); + } + + public static final int DYNAMIC_OPERATOR_FIELD_NUMBER = 30; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public boolean hasDynamicOperator() { + return operationCase_ == 30; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression getDynamicOperator() { + if (operationCase_ == 30) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.getDefaultInstance(); + } + + private void initFields() { + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (hasBlock()) { + if (!getBlock().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasBreak()) { + if (!getBreak().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasCall()) { + if (!getCall().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasClassReference()) { + if (!getClassReference().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasComposite()) { + if (!getComposite().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasConst()) { + if (!getConst().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasContinue()) { + if (!getContinue().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDelegatingConstructorCall()) { + if (!getDelegatingConstructorCall().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDoWhile()) { + if (!getDoWhile().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasEnumConstructorCall()) { + if (!getEnumConstructorCall().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasFunctionReference()) { + if (!getFunctionReference().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasGetClass()) { + if (!getGetClass().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasGetEnumValue()) { + if (!getGetEnumValue().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasGetField()) { + if (!getGetField().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasGetObject()) { + if (!getGetObject().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasGetValue()) { + if (!getGetValue().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasInstanceInitializerCall()) { + if (!getInstanceInitializerCall().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasPropertyReference()) { + if (!getPropertyReference().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasReturn()) { + if (!getReturn().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasSetField()) { + if (!getSetField().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasSetVariable()) { + if (!getSetVariable().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasStringConcat()) { + if (!getStringConcat().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasThrow()) { + if (!getThrow().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasTry()) { + if (!getTry().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasTypeOp()) { + if (!getTypeOp().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasVararg()) { + if (!getVararg().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasWhen()) { + if (!getWhen().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasWhile()) { + if (!getWhile().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDynamicMember()) { + if (!getDynamicMember().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDynamicOperator()) { + if (!getDynamicOperator().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (operationCase_ == 1) { + output.writeMessage(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock) operation_); + } + if (operationCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak) operation_); + } + if (operationCase_ == 3) { + output.writeMessage(3, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall) operation_); + } + if (operationCase_ == 4) { + output.writeMessage(4, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference) operation_); + } + if (operationCase_ == 5) { + output.writeMessage(5, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite) operation_); + } + if (operationCase_ == 6) { + output.writeMessage(6, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst) operation_); + } + if (operationCase_ == 7) { + output.writeMessage(7, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue) operation_); + } + if (operationCase_ == 8) { + output.writeMessage(8, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall) operation_); + } + if (operationCase_ == 9) { + output.writeMessage(9, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile) operation_); + } + if (operationCase_ == 10) { + output.writeMessage(10, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall) operation_); + } + if (operationCase_ == 11) { + output.writeMessage(11, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference) operation_); + } + if (operationCase_ == 12) { + output.writeMessage(12, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass) operation_); + } + if (operationCase_ == 13) { + output.writeMessage(13, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue) operation_); + } + if (operationCase_ == 14) { + output.writeMessage(14, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField) operation_); + } + if (operationCase_ == 15) { + output.writeMessage(15, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject) operation_); + } + if (operationCase_ == 16) { + output.writeMessage(16, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue) operation_); + } + if (operationCase_ == 17) { + output.writeMessage(17, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall) operation_); + } + if (operationCase_ == 18) { + output.writeMessage(18, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference) operation_); + } + if (operationCase_ == 19) { + output.writeMessage(19, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn) operation_); + } + if (operationCase_ == 20) { + output.writeMessage(20, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField) operation_); + } + if (operationCase_ == 21) { + output.writeMessage(21, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable) operation_); + } + if (operationCase_ == 22) { + output.writeMessage(22, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat) operation_); + } + if (operationCase_ == 23) { + output.writeMessage(23, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow) operation_); + } + if (operationCase_ == 24) { + output.writeMessage(24, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry) operation_); + } + if (operationCase_ == 25) { + output.writeMessage(25, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp) operation_); + } + if (operationCase_ == 26) { + output.writeMessage(26, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg) operation_); + } + if (operationCase_ == 27) { + output.writeMessage(27, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen) operation_); + } + if (operationCase_ == 28) { + output.writeMessage(28, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile) operation_); + } + if (operationCase_ == 29) { + output.writeMessage(29, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression) operation_); + } + if (operationCase_ == 30) { + output.writeMessage(30, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression) operation_); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (operationCase_ == 1) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock) operation_); + } + if (operationCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak) operation_); + } + if (operationCase_ == 3) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall) operation_); + } + if (operationCase_ == 4) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference) operation_); + } + if (operationCase_ == 5) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite) operation_); + } + if (operationCase_ == 6) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(6, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst) operation_); + } + if (operationCase_ == 7) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(7, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue) operation_); + } + if (operationCase_ == 8) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(8, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall) operation_); + } + if (operationCase_ == 9) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(9, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile) operation_); + } + if (operationCase_ == 10) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(10, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall) operation_); + } + if (operationCase_ == 11) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(11, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference) operation_); + } + if (operationCase_ == 12) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(12, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass) operation_); + } + if (operationCase_ == 13) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(13, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue) operation_); + } + if (operationCase_ == 14) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(14, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField) operation_); + } + if (operationCase_ == 15) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(15, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject) operation_); + } + if (operationCase_ == 16) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(16, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue) operation_); + } + if (operationCase_ == 17) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(17, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall) operation_); + } + if (operationCase_ == 18) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(18, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference) operation_); + } + if (operationCase_ == 19) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(19, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn) operation_); + } + if (operationCase_ == 20) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(20, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField) operation_); + } + if (operationCase_ == 21) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(21, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable) operation_); + } + if (operationCase_ == 22) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(22, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat) operation_); + } + if (operationCase_ == 23) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(23, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow) operation_); + } + if (operationCase_ == 24) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(24, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry) operation_); + } + if (operationCase_ == 25) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(25, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp) operation_); + } + if (operationCase_ == 26) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(26, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg) operation_); + } + if (operationCase_ == 27) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(27, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen) operation_); + } + if (operationCase_ == 28) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(28, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile) operation_); + } + if (operationCase_ == 29) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(29, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression) operation_); + } + if (operationCase_ == 30) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(30, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression) operation_); + } + 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.KotlinIr.IrOperation 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.KotlinIr.IrOperation 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.KotlinIr.IrOperation parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation 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.KotlinIr.IrOperation parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation 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.KotlinIr.IrOperation parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation 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.KotlinIr.IrOperation parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation 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.KotlinIr.IrOperation prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrOperation} + * + * 
+     * TODO: we need an extension mechanism to accomodate new
+     * IR operators in upcoming releases.
+     *
+ */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrOperation) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperationOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + operationCase_ = 0; + operation_ = null; + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (operationCase_ == 1) { + result.operation_ = operation_; + } + if (operationCase_ == 2) { + result.operation_ = operation_; + } + if (operationCase_ == 3) { + result.operation_ = operation_; + } + if (operationCase_ == 4) { + result.operation_ = operation_; + } + if (operationCase_ == 5) { + result.operation_ = operation_; + } + if (operationCase_ == 6) { + result.operation_ = operation_; + } + if (operationCase_ == 7) { + result.operation_ = operation_; + } + if (operationCase_ == 8) { + result.operation_ = operation_; + } + if (operationCase_ == 9) { + result.operation_ = operation_; + } + if (operationCase_ == 10) { + result.operation_ = operation_; + } + if (operationCase_ == 11) { + result.operation_ = operation_; + } + if (operationCase_ == 12) { + result.operation_ = operation_; + } + if (operationCase_ == 13) { + result.operation_ = operation_; + } + if (operationCase_ == 14) { + result.operation_ = operation_; + } + if (operationCase_ == 15) { + result.operation_ = operation_; + } + if (operationCase_ == 16) { + result.operation_ = operation_; + } + if (operationCase_ == 17) { + result.operation_ = operation_; + } + if (operationCase_ == 18) { + result.operation_ = operation_; + } + if (operationCase_ == 19) { + result.operation_ = operation_; + } + if (operationCase_ == 20) { + result.operation_ = operation_; + } + if (operationCase_ == 21) { + result.operation_ = operation_; + } + if (operationCase_ == 22) { + result.operation_ = operation_; + } + if (operationCase_ == 23) { + result.operation_ = operation_; + } + if (operationCase_ == 24) { + result.operation_ = operation_; + } + if (operationCase_ == 25) { + result.operation_ = operation_; + } + if (operationCase_ == 26) { + result.operation_ = operation_; + } + if (operationCase_ == 27) { + result.operation_ = operation_; + } + if (operationCase_ == 28) { + result.operation_ = operation_; + } + if (operationCase_ == 29) { + result.operation_ = operation_; + } + if (operationCase_ == 30) { + result.operation_ = operation_; + } + result.bitField0_ = to_bitField0_; + result.operationCase_ = operationCase_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.getDefaultInstance()) return this; + switch (other.getOperationCase()) { + case BLOCK: { + mergeBlock(other.getBlock()); + break; + } + case BREAK: { + mergeBreak(other.getBreak()); + break; + } + case CALL: { + mergeCall(other.getCall()); + break; + } + case CLASS_REFERENCE: { + mergeClassReference(other.getClassReference()); + break; + } + case COMPOSITE: { + mergeComposite(other.getComposite()); + break; + } + case CONST: { + mergeConst(other.getConst()); + break; + } + case CONTINUE: { + mergeContinue(other.getContinue()); + break; + } + case DELEGATING_CONSTRUCTOR_CALL: { + mergeDelegatingConstructorCall(other.getDelegatingConstructorCall()); + break; + } + case DO_WHILE: { + mergeDoWhile(other.getDoWhile()); + break; + } + case ENUM_CONSTRUCTOR_CALL: { + mergeEnumConstructorCall(other.getEnumConstructorCall()); + break; + } + case FUNCTION_REFERENCE: { + mergeFunctionReference(other.getFunctionReference()); + break; + } + case GET_CLASS: { + mergeGetClass(other.getGetClass()); + break; + } + case GET_ENUM_VALUE: { + mergeGetEnumValue(other.getGetEnumValue()); + break; + } + case GET_FIELD: { + mergeGetField(other.getGetField()); + break; + } + case GET_OBJECT: { + mergeGetObject(other.getGetObject()); + break; + } + case GET_VALUE: { + mergeGetValue(other.getGetValue()); + break; + } + case INSTANCE_INITIALIZER_CALL: { + mergeInstanceInitializerCall(other.getInstanceInitializerCall()); + break; + } + case PROPERTY_REFERENCE: { + mergePropertyReference(other.getPropertyReference()); + break; + } + case RETURN: { + mergeReturn(other.getReturn()); + break; + } + case SET_FIELD: { + mergeSetField(other.getSetField()); + break; + } + case SET_VARIABLE: { + mergeSetVariable(other.getSetVariable()); + break; + } + case STRING_CONCAT: { + mergeStringConcat(other.getStringConcat()); + break; + } + case THROW: { + mergeThrow(other.getThrow()); + break; + } + case TRY: { + mergeTry(other.getTry()); + break; + } + case TYPE_OP: { + mergeTypeOp(other.getTypeOp()); + break; + } + case VARARG: { + mergeVararg(other.getVararg()); + break; + } + case WHEN: { + mergeWhen(other.getWhen()); + break; + } + case WHILE: { + mergeWhile(other.getWhile()); + break; + } + case DYNAMIC_MEMBER: { + mergeDynamicMember(other.getDynamicMember()); + break; + } + case DYNAMIC_OPERATOR: { + mergeDynamicOperator(other.getDynamicOperator()); + break; + } + case OPERATION_NOT_SET: { + break; + } + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (hasBlock()) { + if (!getBlock().isInitialized()) { + + return false; + } + } + if (hasBreak()) { + if (!getBreak().isInitialized()) { + + return false; + } + } + if (hasCall()) { + if (!getCall().isInitialized()) { + + return false; + } + } + if (hasClassReference()) { + if (!getClassReference().isInitialized()) { + + return false; + } + } + if (hasComposite()) { + if (!getComposite().isInitialized()) { + + return false; + } + } + if (hasConst()) { + if (!getConst().isInitialized()) { + + return false; + } + } + if (hasContinue()) { + if (!getContinue().isInitialized()) { + + return false; + } + } + if (hasDelegatingConstructorCall()) { + if (!getDelegatingConstructorCall().isInitialized()) { + + return false; + } + } + if (hasDoWhile()) { + if (!getDoWhile().isInitialized()) { + + return false; + } + } + if (hasEnumConstructorCall()) { + if (!getEnumConstructorCall().isInitialized()) { + + return false; + } + } + if (hasFunctionReference()) { + if (!getFunctionReference().isInitialized()) { + + return false; + } + } + if (hasGetClass()) { + if (!getGetClass().isInitialized()) { + + return false; + } + } + if (hasGetEnumValue()) { + if (!getGetEnumValue().isInitialized()) { + + return false; + } + } + if (hasGetField()) { + if (!getGetField().isInitialized()) { + + return false; + } + } + if (hasGetObject()) { + if (!getGetObject().isInitialized()) { + + return false; + } + } + if (hasGetValue()) { + if (!getGetValue().isInitialized()) { + + return false; + } + } + if (hasInstanceInitializerCall()) { + if (!getInstanceInitializerCall().isInitialized()) { + + return false; + } + } + if (hasPropertyReference()) { + if (!getPropertyReference().isInitialized()) { + + return false; + } + } + if (hasReturn()) { + if (!getReturn().isInitialized()) { + + return false; + } + } + if (hasSetField()) { + if (!getSetField().isInitialized()) { + + return false; + } + } + if (hasSetVariable()) { + if (!getSetVariable().isInitialized()) { + + return false; + } + } + if (hasStringConcat()) { + if (!getStringConcat().isInitialized()) { + + return false; + } + } + if (hasThrow()) { + if (!getThrow().isInitialized()) { + + return false; + } + } + if (hasTry()) { + if (!getTry().isInitialized()) { + + return false; + } + } + if (hasTypeOp()) { + if (!getTypeOp().isInitialized()) { + + return false; + } + } + if (hasVararg()) { + if (!getVararg().isInitialized()) { + + return false; + } + } + if (hasWhen()) { + if (!getWhen().isInitialized()) { + + return false; + } + } + if (hasWhile()) { + if (!getWhile().isInitialized()) { + + return false; + } + } + if (hasDynamicMember()) { + if (!getDynamicMember().isInitialized()) { + + return false; + } + } + if (hasDynamicOperator()) { + if (!getDynamicOperator().isInitialized()) { + + 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.KotlinIr.IrOperation parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int operationCase_ = 0; + private java.lang.Object operation_; + public OperationCase + getOperationCase() { + return OperationCase.valueOf( + operationCase_); + } + + public Builder clearOperation() { + operationCase_ = 0; + operation_ = null; + return this; + } + + private int bitField0_; + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + public boolean hasBlock() { + return operationCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock getBlock() { + if (operationCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + public Builder setBlock(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + public Builder setBlock( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + public Builder mergeBlock(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock value) { + if (operationCase_ == 1 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlock block = 1; + */ + public Builder clearBlock() { + if (operationCase_ == 1) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + public boolean hasBreak() { + return operationCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak getBreak() { + if (operationCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + public Builder setBreak(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + public Builder setBreak( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + public Builder mergeBreak(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak value) { + if (operationCase_ == 2 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBreak) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBreak break = 2; + */ + public Builder clearBreak() { + if (operationCase_ == 2) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + public boolean hasCall() { + return operationCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall getCall() { + if (operationCase_ == 3) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + public Builder setCall(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + public Builder setCall( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + public Builder mergeCall(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall value) { + if (operationCase_ == 3 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCall call = 3; + */ + public Builder clearCall() { + if (operationCase_ == 3) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + public boolean hasClassReference() { + return operationCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference getClassReference() { + if (operationCase_ == 4) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + public Builder setClassReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + public Builder setClassReference( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + public Builder mergeClassReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference value) { + if (operationCase_ == 4 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassReference) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClassReference class_reference = 4; + */ + public Builder clearClassReference() { + if (operationCase_ == 4) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + public boolean hasComposite() { + return operationCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite getComposite() { + if (operationCase_ == 5) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + public Builder setComposite(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + public Builder setComposite( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + public Builder mergeComposite(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite value) { + if (operationCase_ == 5 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrComposite composite = 5; + */ + public Builder clearComposite() { + if (operationCase_ == 5) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + public boolean hasConst() { + return operationCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst getConst() { + if (operationCase_ == 6) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + public Builder setConst(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + public Builder setConst( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + public Builder mergeConst(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst value) { + if (operationCase_ == 6 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConst) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConst const = 6; + */ + public Builder clearConst() { + if (operationCase_ == 6) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + public boolean hasContinue() { + return operationCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue getContinue() { + if (operationCase_ == 7) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + public Builder setContinue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + public Builder setContinue( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + public Builder mergeContinue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue value) { + if (operationCase_ == 7 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrContinue) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrContinue continue = 7; + */ + public Builder clearContinue() { + if (operationCase_ == 7) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public boolean hasDelegatingConstructorCall() { + return operationCase_ == 8; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall getDelegatingConstructorCall() { + if (operationCase_ == 8) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public Builder setDelegatingConstructorCall(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public Builder setDelegatingConstructorCall( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public Builder mergeDelegatingConstructorCall(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall value) { + if (operationCase_ == 8 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDelegatingConstructorCall) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public Builder clearDelegatingConstructorCall() { + if (operationCase_ == 8) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + public boolean hasDoWhile() { + return operationCase_ == 9; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile getDoWhile() { + if (operationCase_ == 9) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + public Builder setDoWhile(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + public Builder setDoWhile( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + public Builder mergeDoWhile(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile value) { + if (operationCase_ == 9 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDoWhile) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDoWhile do_while = 9; + */ + public Builder clearDoWhile() { + if (operationCase_ == 9) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + public boolean hasEnumConstructorCall() { + return operationCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall getEnumConstructorCall() { + if (operationCase_ == 10) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + public Builder setEnumConstructorCall(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + public Builder setEnumConstructorCall( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + public Builder mergeEnumConstructorCall(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall value) { + if (operationCase_ == 10 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumConstructorCall) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumConstructorCall enum_constructor_call = 10; + */ + public Builder clearEnumConstructorCall() { + if (operationCase_ == 10) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + public boolean hasFunctionReference() { + return operationCase_ == 11; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference getFunctionReference() { + if (operationCase_ == 11) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + public Builder setFunctionReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + public Builder setFunctionReference( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + public Builder mergeFunctionReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference value) { + if (operationCase_ == 11 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionReference) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunctionReference function_reference = 11; + */ + public Builder clearFunctionReference() { + if (operationCase_ == 11) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + public boolean hasGetClass() { + return operationCase_ == 12; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass getGetClass() { + if (operationCase_ == 12) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + public Builder setGetClass(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 12; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + public Builder setGetClass( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 12; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + public Builder mergeGetClass(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass value) { + if (operationCase_ == 12 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetClass) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 12; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetClass get_class = 12; + */ + public Builder clearGetClass() { + if (operationCase_ == 12) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + public boolean hasGetEnumValue() { + return operationCase_ == 13; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue getGetEnumValue() { + if (operationCase_ == 13) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + public Builder setGetEnumValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 13; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + public Builder setGetEnumValue( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 13; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + public Builder mergeGetEnumValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue value) { + if (operationCase_ == 13 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetEnumValue) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 13; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetEnumValue get_enum_value = 13; + */ + public Builder clearGetEnumValue() { + if (operationCase_ == 13) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + public boolean hasGetField() { + return operationCase_ == 14; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField getGetField() { + if (operationCase_ == 14) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + public Builder setGetField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 14; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + public Builder setGetField( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 14; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + public Builder mergeGetField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField value) { + if (operationCase_ == 14 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetField) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 14; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetField get_field = 14; + */ + public Builder clearGetField() { + if (operationCase_ == 14) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + public boolean hasGetObject() { + return operationCase_ == 15; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject getGetObject() { + if (operationCase_ == 15) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + public Builder setGetObject(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 15; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + public Builder setGetObject( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 15; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + public Builder mergeGetObject(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject value) { + if (operationCase_ == 15 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetObject) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 15; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetObject get_object = 15; + */ + public Builder clearGetObject() { + if (operationCase_ == 15) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + public boolean hasGetValue() { + return operationCase_ == 16; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue getGetValue() { + if (operationCase_ == 16) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + public Builder setGetValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 16; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + public Builder setGetValue( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 16; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + public Builder mergeGetValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue value) { + if (operationCase_ == 16 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrGetValue) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 16; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrGetValue get_value = 16; + */ + public Builder clearGetValue() { + if (operationCase_ == 16) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public boolean hasInstanceInitializerCall() { + return operationCase_ == 17; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall getInstanceInitializerCall() { + if (operationCase_ == 17) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public Builder setInstanceInitializerCall(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 17; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public Builder setInstanceInitializerCall( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 17; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public Builder mergeInstanceInitializerCall(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall value) { + if (operationCase_ == 17 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrInstanceInitializerCall) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 17; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public Builder clearInstanceInitializerCall() { + if (operationCase_ == 17) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + public boolean hasPropertyReference() { + return operationCase_ == 18; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference getPropertyReference() { + if (operationCase_ == 18) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + public Builder setPropertyReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 18; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + public Builder setPropertyReference( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 18; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + public Builder mergePropertyReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference value) { + if (operationCase_ == 18 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyReference) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 18; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrPropertyReference property_reference = 18; + */ + public Builder clearPropertyReference() { + if (operationCase_ == 18) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + public boolean hasReturn() { + return operationCase_ == 19; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn getReturn() { + if (operationCase_ == 19) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + public Builder setReturn(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 19; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + public Builder setReturn( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 19; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + public Builder mergeReturn(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn value) { + if (operationCase_ == 19 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrReturn) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 19; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrReturn return = 19; + */ + public Builder clearReturn() { + if (operationCase_ == 19) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + public boolean hasSetField() { + return operationCase_ == 20; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField getSetField() { + if (operationCase_ == 20) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + public Builder setSetField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 20; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + public Builder setSetField( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 20; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + public Builder mergeSetField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField value) { + if (operationCase_ == 20 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetField) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 20; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetField set_field = 20; + */ + public Builder clearSetField() { + if (operationCase_ == 20) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + public boolean hasSetVariable() { + return operationCase_ == 21; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable getSetVariable() { + if (operationCase_ == 21) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + public Builder setSetVariable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 21; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + public Builder setSetVariable( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 21; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + public Builder mergeSetVariable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable value) { + if (operationCase_ == 21 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSetVariable) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 21; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSetVariable set_variable = 21; + */ + public Builder clearSetVariable() { + if (operationCase_ == 21) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + public boolean hasStringConcat() { + return operationCase_ == 22; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat getStringConcat() { + if (operationCase_ == 22) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + public Builder setStringConcat(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 22; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + public Builder setStringConcat( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 22; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + public Builder mergeStringConcat(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat value) { + if (operationCase_ == 22 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStringConcat) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 22; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStringConcat string_concat = 22; + */ + public Builder clearStringConcat() { + if (operationCase_ == 22) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + public boolean hasThrow() { + return operationCase_ == 23; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow getThrow() { + if (operationCase_ == 23) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + public Builder setThrow(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 23; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + public Builder setThrow( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 23; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + public Builder mergeThrow(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow value) { + if (operationCase_ == 23 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrThrow) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 23; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrThrow throw = 23; + */ + public Builder clearThrow() { + if (operationCase_ == 23) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + public boolean hasTry() { + return operationCase_ == 24; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry getTry() { + if (operationCase_ == 24) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + public Builder setTry(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 24; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + public Builder setTry( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 24; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + public Builder mergeTry(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry value) { + if (operationCase_ == 24 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTry) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 24; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTry try = 24; + */ + public Builder clearTry() { + if (operationCase_ == 24) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + public boolean hasTypeOp() { + return operationCase_ == 25; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp getTypeOp() { + if (operationCase_ == 25) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + public Builder setTypeOp(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 25; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + public Builder setTypeOp( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 25; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + public Builder mergeTypeOp(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp value) { + if (operationCase_ == 25 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeOp) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 25; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeOp type_op = 25; + */ + public Builder clearTypeOp() { + if (operationCase_ == 25) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + public boolean hasVararg() { + return operationCase_ == 26; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg getVararg() { + if (operationCase_ == 26) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + public Builder setVararg(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 26; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + public Builder setVararg( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 26; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + public Builder mergeVararg(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg value) { + if (operationCase_ == 26 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVararg) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 26; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVararg vararg = 26; + */ + public Builder clearVararg() { + if (operationCase_ == 26) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + public boolean hasWhen() { + return operationCase_ == 27; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen getWhen() { + if (operationCase_ == 27) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + public Builder setWhen(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 27; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + public Builder setWhen( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 27; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + public Builder mergeWhen(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen value) { + if (operationCase_ == 27 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 27; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhen when = 27; + */ + public Builder clearWhen() { + if (operationCase_ == 27) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + public boolean hasWhile() { + return operationCase_ == 28; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile getWhile() { + if (operationCase_ == 28) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + public Builder setWhile(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 28; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + public Builder setWhile( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 28; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + public Builder mergeWhile(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile value) { + if (operationCase_ == 28 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhile) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 28; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrWhile while = 28; + */ + public Builder clearWhile() { + if (operationCase_ == 28) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + public boolean hasDynamicMember() { + return operationCase_ == 29; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression getDynamicMember() { + if (operationCase_ == 29) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + public Builder setDynamicMember(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 29; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + public Builder setDynamicMember( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 29; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + public Builder mergeDynamicMember(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression value) { + if (operationCase_ == 29 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicMemberExpression) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 29; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicMemberExpression dynamic_member = 29; + */ + public Builder clearDynamicMember() { + if (operationCase_ == 29) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public boolean hasDynamicOperator() { + return operationCase_ == 30; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression getDynamicOperator() { + if (operationCase_ == 30) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression) operation_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public Builder setDynamicOperator(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 30; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public Builder setDynamicOperator( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 30; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public Builder mergeDynamicOperator(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression value) { + if (operationCase_ == 30 && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDynamicOperatorExpression) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 30; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public Builder clearDynamicOperator() { + if (operationCase_ == 30) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrOperation) + } + + static { + defaultInstance = new IrOperation(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrOperation) + } + + public interface IrExpressionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrExpression) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + boolean hasOperation(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation getOperation(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + boolean hasCoordinates(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrExpression} + */ + public static final class IrExpression extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrExpression) + IrExpressionOrBuilder { + // Use IrExpression.newBuilder() to construct. + private IrExpression(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrExpression(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrExpression defaultInstance; + public static IrExpression getDefaultInstance() { + return defaultInstance; + } + + public IrExpression getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrExpression( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = operation_.toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(operation_); + operation_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(type_); + type_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = coordinates_.toBuilder(); + } + coordinates_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(coordinates_); + coordinates_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + 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 IrExpression parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrExpression(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int OPERATION_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation operation_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + public boolean hasOperation() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation getOperation() { + return operation_; + } + + public static final int TYPE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + + public static final int COORDINATES_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates coordinates_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates() { + return coordinates_; + } + + private void initFields() { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.getDefaultInstance(); + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasOperation()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasCoordinates()) { + memoizedIsInitialized = 0; + return false; + } + if (!getOperation().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getType().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCoordinates().isInitialized()) { + 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.writeMessage(1, operation_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, type_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, coordinates_); + } + 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 + .computeMessageSize(1, operation_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, type_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, coordinates_); + } + 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.KotlinIr.IrExpression 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.KotlinIr.IrExpression 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.KotlinIr.IrExpression parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression 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.KotlinIr.IrExpression parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression 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.KotlinIr.IrExpression parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression 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.KotlinIr.IrExpression parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression 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.KotlinIr.IrExpression prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrExpression} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrExpression) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpressionOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.operation_ = operation_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.coordinates_ = coordinates_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) return this; + if (other.hasOperation()) { + mergeOperation(other.getOperation()); + } + if (other.hasType()) { + mergeType(other.getType()); + } + if (other.hasCoordinates()) { + mergeCoordinates(other.getCoordinates()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasOperation()) { + + return false; + } + if (!hasType()) { + + return false; + } + if (!hasCoordinates()) { + + return false; + } + if (!getOperation().isInitialized()) { + + return false; + } + if (!getType().isInitialized()) { + + return false; + } + if (!getCoordinates().isInitialized()) { + + 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.KotlinIr.IrExpression parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + public boolean hasOperation() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation getOperation() { + return operation_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + public Builder setOperation(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + public Builder setOperation( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.Builder builderForValue) { + operation_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + public Builder mergeOperation(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + operation_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.getDefaultInstance()) { + operation_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.newBuilder(operation_).mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrOperation operation = 1; + */ + public Builder clearOperation() { + operation_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrOperation.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public Builder setType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public Builder setType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public Builder mergeType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + type_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 2; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates() { + return coordinates_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + public Builder setCoordinates(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates value) { + if (value == null) { + throw new NullPointerException(); + } + coordinates_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + public Builder setCoordinates( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.Builder builderForValue) { + coordinates_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + public Builder mergeCoordinates(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + coordinates_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance()) { + coordinates_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.newBuilder(coordinates_).mergeFrom(value).buildPartial(); + } else { + coordinates_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 3; + */ + public Builder clearCoordinates() { + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrExpression) + } + + static { + defaultInstance = new IrExpression(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrExpression) + } + + public interface NullableIrExpressionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + boolean hasExpression(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression} + */ + public static final class NullableIrExpression extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression) + NullableIrExpressionOrBuilder { + // Use NullableIrExpression.newBuilder() to construct. + private NullableIrExpression(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private NullableIrExpression(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final NullableIrExpression defaultInstance; + public static NullableIrExpression getDefaultInstance() { + return defaultInstance; + } + + public NullableIrExpression getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private NullableIrExpression( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = expression_.toBuilder(); + } + expression_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(expression_); + expression_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + 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 NullableIrExpression parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new NullableIrExpression(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int EXPRESSION_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression expression_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public boolean hasExpression() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression() { + return expression_; + } + + private void initFields() { + expression_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (hasExpression()) { + if (!getExpression().isInitialized()) { + 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.writeMessage(1, expression_); + } + 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 + .computeMessageSize(1, expression_); + } + 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.KotlinIr.NullableIrExpression 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.KotlinIr.NullableIrExpression 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.KotlinIr.NullableIrExpression parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression 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.KotlinIr.NullableIrExpression parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression 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.KotlinIr.NullableIrExpression parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression 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.KotlinIr.NullableIrExpression parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression 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.KotlinIr.NullableIrExpression prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpressionOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + expression_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.expression_ = expression_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression.getDefaultInstance()) return this; + if (other.hasExpression()) { + mergeExpression(other.getExpression()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (hasExpression()) { + if (!getExpression().isInitialized()) { + + 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.KotlinIr.NullableIrExpression parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.NullableIrExpression) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression expression_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public boolean hasExpression() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression() { + return expression_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder setExpression(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + expression_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder setExpression( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + expression_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder mergeExpression(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + expression_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + expression_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(expression_).mergeFrom(value).buildPartial(); + } else { + expression_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 1; + */ + public Builder clearExpression() { + expression_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression) + } + + static { + defaultInstance = new NullableIrExpression(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.NullableIrExpression) + } + + public interface IrTypeAliasOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias} + * + * 
+   * Nothing for now.
+   *
+ */ + public static final class IrTypeAlias extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias) + IrTypeAliasOrBuilder { + // Use IrTypeAlias.newBuilder() to construct. + private IrTypeAlias(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrTypeAlias(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrTypeAlias defaultInstance; + public static IrTypeAlias getDefaultInstance() { + return defaultInstance; + } + + public IrTypeAlias getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrTypeAlias( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + initFields(); + 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); + 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; + } + } + } + } 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 IrTypeAlias parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrTypeAlias(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private void initFields() { + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + 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.KotlinIr.IrTypeAlias 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.KotlinIr.IrTypeAlias 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.KotlinIr.IrTypeAlias parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias 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.KotlinIr.IrTypeAlias parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias 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.KotlinIr.IrTypeAlias parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias 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.KotlinIr.IrTypeAlias parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias 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.KotlinIr.IrTypeAlias prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias} + * + * 
+     * Nothing for now.
+     *
+ */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAliasOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias(this); + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.getDefaultInstance()) return this; + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + 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.KotlinIr.IrTypeAlias parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias) + } + + static { + defaultInstance = new IrTypeAlias(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias) + } + + public interface IrFunctionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrFunction) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + boolean hasBase(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase getBase(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 3; + */ + boolean hasModality(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind getModality(); + + /** + * required bool is_tailrec = 4; + */ + boolean hasIsTailrec(); + /** + * required bool is_tailrec = 4; + */ + boolean getIsTailrec(); + + /** + * required bool is_suspend = 5; + */ + boolean hasIsSuspend(); + /** + * required bool is_suspend = 5; + */ + boolean getIsSuspend(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + java.util.List + getOverriddenList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getOverridden(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + int getOverriddenCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrFunction} + */ + public static final class IrFunction extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrFunction) + IrFunctionOrBuilder { + // Use IrFunction.newBuilder() to construct. + private IrFunction(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrFunction(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrFunction defaultInstance; + public static IrFunction getDefaultInstance() { + return defaultInstance; + } + + public IrFunction getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrFunction( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = base_.toBuilder(); + } + base_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(base_); + base_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 24: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000004; + modality_ = value; + } + break; + } + case 32: { + bitField0_ |= 0x00000008; + isTailrec_ = input.readBool(); + break; + } + case 40: { + bitField0_ |= 0x00000010; + isSuspend_ = input.readBool(); + break; + } + case 50: { + if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + overridden_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000020; + } + overridden_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + overridden_ = java.util.Collections.unmodifiableList(overridden_); + } + 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 IrFunction parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrFunction(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int BASE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase base_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public boolean hasBase() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase getBase() { + return base_; + } + + public static final int MODALITY_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind modality_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 3; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind getModality() { + return modality_; + } + + public static final int IS_TAILREC_FIELD_NUMBER = 4; + private boolean isTailrec_; + /** + * required bool is_tailrec = 4; + */ + public boolean hasIsTailrec() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required bool is_tailrec = 4; + */ + public boolean getIsTailrec() { + return isTailrec_; + } + + public static final int IS_SUSPEND_FIELD_NUMBER = 5; + private boolean isSuspend_; + /** + * required bool is_suspend = 5; + */ + public boolean hasIsSuspend() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required bool is_suspend = 5; + */ + public boolean getIsSuspend() { + return isSuspend_; + } + + public static final int OVERRIDDEN_FIELD_NUMBER = 6; + private java.util.List overridden_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public java.util.List getOverriddenList() { + return overridden_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public java.util.List + getOverriddenOrBuilderList() { + return overridden_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public int getOverriddenCount() { + return overridden_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getOverridden(int index) { + return overridden_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbolOrBuilder getOverriddenOrBuilder( + int index) { + return overridden_.get(index); + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + base_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance(); + modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + isTailrec_ = false; + isSuspend_ = false; + overridden_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasBase()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasModality()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsTailrec()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsSuspend()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getBase().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getOverriddenCount(); i++) { + if (!getOverridden(i).isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, base_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeEnum(3, modality_.getNumber()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeBool(4, isTailrec_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBool(5, isSuspend_); + } + for (int i = 0; i < overridden_.size(); i++) { + output.writeMessage(6, overridden_.get(i)); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, base_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeEnumSize(3, modality_.getNumber()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(4, isTailrec_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(5, isSuspend_); + } + for (int i = 0; i < overridden_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(6, overridden_.get(i)); + } + 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.KotlinIr.IrFunction 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.KotlinIr.IrFunction 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.KotlinIr.IrFunction parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction 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.KotlinIr.IrFunction parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction 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.KotlinIr.IrFunction parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction 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.KotlinIr.IrFunction parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction 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.KotlinIr.IrFunction prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrFunction} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrFunction) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + base_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + bitField0_ = (bitField0_ & ~0x00000004); + isTailrec_ = false; + bitField0_ = (bitField0_ & ~0x00000008); + isSuspend_ = false; + bitField0_ = (bitField0_ & ~0x00000010); + overridden_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.base_ = base_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.modality_ = modality_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.isTailrec_ = isTailrec_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.isSuspend_ = isSuspend_; + if (((bitField0_ & 0x00000020) == 0x00000020)) { + overridden_ = java.util.Collections.unmodifiableList(overridden_); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.overridden_ = overridden_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasBase()) { + mergeBase(other.getBase()); + } + if (other.hasModality()) { + setModality(other.getModality()); + } + if (other.hasIsTailrec()) { + setIsTailrec(other.getIsTailrec()); + } + if (other.hasIsSuspend()) { + setIsSuspend(other.getIsSuspend()); + } + if (!other.overridden_.isEmpty()) { + if (overridden_.isEmpty()) { + overridden_ = other.overridden_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureOverriddenIsMutable(); + overridden_.addAll(other.overridden_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasBase()) { + + return false; + } + if (!hasModality()) { + + return false; + } + if (!hasIsTailrec()) { + + return false; + } + if (!hasIsSuspend()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getBase().isInitialized()) { + + return false; + } + for (int i = 0; i < getOverriddenCount(); i++) { + if (!getOverridden(i).isInitialized()) { + + 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.KotlinIr.IrFunction parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase base_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public boolean hasBase() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase getBase() { + return base_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public Builder setBase(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase value) { + if (value == null) { + throw new NullPointerException(); + } + base_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public Builder setBase( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.Builder builderForValue) { + base_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public Builder mergeBase(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + base_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance()) { + base_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.newBuilder(base_).mergeFrom(value).buildPartial(); + } else { + base_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public Builder clearBase() { + base_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 3; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind getModality() { + return modality_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 3; + */ + public Builder setModality(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + modality_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 3; + */ + public Builder clearModality() { + bitField0_ = (bitField0_ & ~0x00000004); + modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + + return this; + } + + private boolean isTailrec_ ; + /** + * required bool is_tailrec = 4; + */ + public boolean hasIsTailrec() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required bool is_tailrec = 4; + */ + public boolean getIsTailrec() { + return isTailrec_; + } + /** + * required bool is_tailrec = 4; + */ + public Builder setIsTailrec(boolean value) { + bitField0_ |= 0x00000008; + isTailrec_ = value; + + return this; + } + /** + * required bool is_tailrec = 4; + */ + public Builder clearIsTailrec() { + bitField0_ = (bitField0_ & ~0x00000008); + isTailrec_ = false; + + return this; + } + + private boolean isSuspend_ ; + /** + * required bool is_suspend = 5; + */ + public boolean hasIsSuspend() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required bool is_suspend = 5; + */ + public boolean getIsSuspend() { + return isSuspend_; + } + /** + * required bool is_suspend = 5; + */ + public Builder setIsSuspend(boolean value) { + bitField0_ |= 0x00000010; + isSuspend_ = value; + + return this; + } + /** + * required bool is_suspend = 5; + */ + public Builder clearIsSuspend() { + bitField0_ = (bitField0_ & ~0x00000010); + isSuspend_ = false; + + return this; + } + + private java.util.List overridden_ = + java.util.Collections.emptyList(); + private void ensureOverriddenIsMutable() { + if (!((bitField0_ & 0x00000020) == 0x00000020)) { + overridden_ = new java.util.ArrayList(overridden_); + bitField0_ |= 0x00000020; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public java.util.List getOverriddenList() { + return java.util.Collections.unmodifiableList(overridden_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public int getOverriddenCount() { + return overridden_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getOverridden(int index) { + return overridden_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder setOverridden( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + ensureOverriddenIsMutable(); + overridden_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder setOverridden( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + ensureOverriddenIsMutable(); + overridden_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder addOverridden(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + ensureOverriddenIsMutable(); + overridden_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder addOverridden( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + ensureOverriddenIsMutable(); + overridden_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder addOverridden( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + ensureOverriddenIsMutable(); + overridden_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder addOverridden( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + ensureOverriddenIsMutable(); + overridden_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder addAllOverridden( + java.lang.Iterable values) { + ensureOverriddenIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, overridden_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder clearOverridden() { + overridden_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder removeOverridden(int index) { + ensureOverriddenIsMutable(); + overridden_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrFunction) + } + + static { + defaultInstance = new IrFunction(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrFunction) + } + + public interface IrFunctionBaseOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + boolean hasVisibility(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility(); + + /** + * required bool is_inline = 3; + */ + boolean hasIsInline(); + /** + * required bool is_inline = 3; + */ + boolean getIsInline(); + + /** + * required bool is_external = 4; + */ + boolean hasIsExternal(); + /** + * required bool is_external = 4; + */ + boolean getIsExternal(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + boolean hasTypeParameters(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer getTypeParameters(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + boolean hasDispatchReceiver(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDispatchReceiver(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + boolean hasExtensionReceiver(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getExtensionReceiver(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + java.util.List + getValueParameterList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getValueParameter(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + int getValueParameterCount(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + boolean hasBody(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getBody(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + boolean hasReturnType(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getReturnType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase} + */ + public static final class IrFunctionBase extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase) + IrFunctionBaseOrBuilder { + // Use IrFunctionBase.newBuilder() to construct. + private IrFunctionBase(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrFunctionBase(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrFunctionBase defaultInstance; + public static IrFunctionBase getDefaultInstance() { + return defaultInstance; + } + + public IrFunctionBase getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrFunctionBase( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = visibility_.toBuilder(); + } + visibility_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(visibility_); + visibility_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 24: { + bitField0_ |= 0x00000004; + isInline_ = input.readBool(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + isExternal_ = input.readBool(); + break; + } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = typeParameters_.toBuilder(); + } + typeParameters_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(typeParameters_); + typeParameters_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + case 50: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000020) == 0x00000020)) { + subBuilder = dispatchReceiver_.toBuilder(); + } + dispatchReceiver_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(dispatchReceiver_); + dispatchReceiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000020; + break; + } + case 58: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000040) == 0x00000040)) { + subBuilder = extensionReceiver_.toBuilder(); + } + extensionReceiver_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(extensionReceiver_); + extensionReceiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000040; + break; + } + case 66: { + if (!((mutable_bitField0_ & 0x00000080) == 0x00000080)) { + valueParameter_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000080; + } + valueParameter_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.PARSER, extensionRegistry)); + break; + } + case 74: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + subBuilder = body_.toBuilder(); + } + body_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(body_); + body_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000080; + break; + } + case 82: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000100) == 0x00000100)) { + subBuilder = returnType_.toBuilder(); + } + returnType_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(returnType_); + returnType_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000100; + 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 { + if (((mutable_bitField0_ & 0x00000080) == 0x00000080)) { + valueParameter_ = java.util.Collections.unmodifiableList(valueParameter_); + } + 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 IrFunctionBase parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrFunctionBase(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + + public static final int VISIBILITY_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility visibility_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility() { + return visibility_; + } + + public static final int IS_INLINE_FIELD_NUMBER = 3; + private boolean isInline_; + /** + * required bool is_inline = 3; + */ + public boolean hasIsInline() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required bool is_inline = 3; + */ + public boolean getIsInline() { + return isInline_; + } + + public static final int IS_EXTERNAL_FIELD_NUMBER = 4; + private boolean isExternal_; + /** + * required bool is_external = 4; + */ + public boolean hasIsExternal() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required bool is_external = 4; + */ + public boolean getIsExternal() { + return isExternal_; + } + + public static final int TYPE_PARAMETERS_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer typeParameters_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + public boolean hasTypeParameters() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer getTypeParameters() { + return typeParameters_; + } + + public static final int DISPATCH_RECEIVER_FIELD_NUMBER = 6; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration dispatchReceiver_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + public boolean hasDispatchReceiver() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDispatchReceiver() { + return dispatchReceiver_; + } + + public static final int EXTENSION_RECEIVER_FIELD_NUMBER = 7; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration extensionReceiver_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + public boolean hasExtensionReceiver() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getExtensionReceiver() { + return extensionReceiver_; + } + + public static final int VALUE_PARAMETER_FIELD_NUMBER = 8; + private java.util.List valueParameter_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public java.util.List getValueParameterList() { + return valueParameter_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public java.util.List + getValueParameterOrBuilderList() { + return valueParameter_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public int getValueParameterCount() { + return valueParameter_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getValueParameter(int index) { + return valueParameter_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrBuilder getValueParameterOrBuilder( + int index) { + return valueParameter_.get(index); + } + + public static final int BODY_FIELD_NUMBER = 9; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement body_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getBody() { + return body_; + } + + public static final int RETURN_TYPE_FIELD_NUMBER = 10; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex returnType_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + public boolean hasReturnType() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getReturnType() { + return returnType_; + } + + private void initFields() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + isInline_ = false; + isExternal_ = false; + typeParameters_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance(); + dispatchReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + extensionReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + valueParameter_ = java.util.Collections.emptyList(); + body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance(); + returnType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasVisibility()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsInline()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsExternal()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasTypeParameters()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasReturnType()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getVisibility().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getTypeParameters().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasDispatchReceiver()) { + if (!getDispatchReceiver().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasExtensionReceiver()) { + if (!getExtensionReceiver().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getValueParameterCount(); i++) { + if (!getValueParameter(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasBody()) { + if (!getBody().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getReturnType().isInitialized()) { + 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.writeMessage(1, name_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, visibility_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBool(3, isInline_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeBool(4, isExternal_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(5, typeParameters_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeMessage(6, dispatchReceiver_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeMessage(7, extensionReceiver_); + } + for (int i = 0; i < valueParameter_.size(); i++) { + output.writeMessage(8, valueParameter_.get(i)); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeMessage(9, body_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + output.writeMessage(10, returnType_); + } + 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 + .computeMessageSize(1, name_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, visibility_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(3, isInline_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(4, isExternal_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, typeParameters_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(6, dispatchReceiver_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(7, extensionReceiver_); + } + for (int i = 0; i < valueParameter_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(8, valueParameter_.get(i)); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(9, body_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(10, returnType_); + } + 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.KotlinIr.IrFunctionBase 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.KotlinIr.IrFunctionBase 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.KotlinIr.IrFunctionBase parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase 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.KotlinIr.IrFunctionBase parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase 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.KotlinIr.IrFunctionBase parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase 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.KotlinIr.IrFunctionBase parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase 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.KotlinIr.IrFunctionBase prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBaseOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + isInline_ = false; + bitField0_ = (bitField0_ & ~0x00000004); + isExternal_ = false; + bitField0_ = (bitField0_ & ~0x00000008); + typeParameters_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); + dispatchReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000020); + extensionReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000040); + valueParameter_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000100); + returnType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000200); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.visibility_ = visibility_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.isInline_ = isInline_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.isExternal_ = isExternal_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.typeParameters_ = typeParameters_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.dispatchReceiver_ = dispatchReceiver_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + result.extensionReceiver_ = extensionReceiver_; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + valueParameter_ = java.util.Collections.unmodifiableList(valueParameter_); + bitField0_ = (bitField0_ & ~0x00000080); + } + result.valueParameter_ = valueParameter_; + if (((from_bitField0_ & 0x00000100) == 0x00000100)) { + to_bitField0_ |= 0x00000080; + } + result.body_ = body_; + if (((from_bitField0_ & 0x00000200) == 0x00000200)) { + to_bitField0_ |= 0x00000100; + } + result.returnType_ = returnType_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance()) return this; + if (other.hasName()) { + mergeName(other.getName()); + } + if (other.hasVisibility()) { + mergeVisibility(other.getVisibility()); + } + if (other.hasIsInline()) { + setIsInline(other.getIsInline()); + } + if (other.hasIsExternal()) { + setIsExternal(other.getIsExternal()); + } + if (other.hasTypeParameters()) { + mergeTypeParameters(other.getTypeParameters()); + } + if (other.hasDispatchReceiver()) { + mergeDispatchReceiver(other.getDispatchReceiver()); + } + if (other.hasExtensionReceiver()) { + mergeExtensionReceiver(other.getExtensionReceiver()); + } + if (!other.valueParameter_.isEmpty()) { + if (valueParameter_.isEmpty()) { + valueParameter_ = other.valueParameter_; + bitField0_ = (bitField0_ & ~0x00000080); + } else { + ensureValueParameterIsMutable(); + valueParameter_.addAll(other.valueParameter_); + } + + } + if (other.hasBody()) { + mergeBody(other.getBody()); + } + if (other.hasReturnType()) { + mergeReturnType(other.getReturnType()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!hasVisibility()) { + + return false; + } + if (!hasIsInline()) { + + return false; + } + if (!hasIsExternal()) { + + return false; + } + if (!hasTypeParameters()) { + + return false; + } + if (!hasReturnType()) { + + return false; + } + if (!getName().isInitialized()) { + + return false; + } + if (!getVisibility().isInitialized()) { + + return false; + } + if (!getTypeParameters().isInitialized()) { + + return false; + } + if (hasDispatchReceiver()) { + if (!getDispatchReceiver().isInitialized()) { + + return false; + } + } + if (hasExtensionReceiver()) { + if (!getExtensionReceiver().isInitialized()) { + + return false; + } + } + for (int i = 0; i < getValueParameterCount(); i++) { + if (!getValueParameter(i).isInitialized()) { + + return false; + } + } + if (hasBody()) { + if (!getBody().isInitialized()) { + + return false; + } + } + if (!getReturnType().isInitialized()) { + + 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.KotlinIr.IrFunctionBase parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility() { + return visibility_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + public Builder setVisibility(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility value) { + if (value == null) { + throw new NullPointerException(); + } + visibility_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + public Builder setVisibility( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.Builder builderForValue) { + visibility_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + public Builder mergeVisibility(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + visibility_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance()) { + visibility_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.newBuilder(visibility_).mergeFrom(value).buildPartial(); + } else { + visibility_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 2; + */ + public Builder clearVisibility() { + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private boolean isInline_ ; + /** + * required bool is_inline = 3; + */ + public boolean hasIsInline() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required bool is_inline = 3; + */ + public boolean getIsInline() { + return isInline_; + } + /** + * required bool is_inline = 3; + */ + public Builder setIsInline(boolean value) { + bitField0_ |= 0x00000004; + isInline_ = value; + + return this; + } + /** + * required bool is_inline = 3; + */ + public Builder clearIsInline() { + bitField0_ = (bitField0_ & ~0x00000004); + isInline_ = false; + + return this; + } + + private boolean isExternal_ ; + /** + * required bool is_external = 4; + */ + public boolean hasIsExternal() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required bool is_external = 4; + */ + public boolean getIsExternal() { + return isExternal_; + } + /** + * required bool is_external = 4; + */ + public Builder setIsExternal(boolean value) { + bitField0_ |= 0x00000008; + isExternal_ = value; + + return this; + } + /** + * required bool is_external = 4; + */ + public Builder clearIsExternal() { + bitField0_ = (bitField0_ & ~0x00000008); + isExternal_ = false; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer typeParameters_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + public boolean hasTypeParameters() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer getTypeParameters() { + return typeParameters_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + public Builder setTypeParameters(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer value) { + if (value == null) { + throw new NullPointerException(); + } + typeParameters_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + public Builder setTypeParameters( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.Builder builderForValue) { + typeParameters_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + public Builder mergeTypeParameters(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + typeParameters_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance()) { + typeParameters_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.newBuilder(typeParameters_).mergeFrom(value).buildPartial(); + } else { + typeParameters_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 5; + */ + public Builder clearTypeParameters() { + typeParameters_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration dispatchReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + public boolean hasDispatchReceiver() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDispatchReceiver() { + return dispatchReceiver_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + public Builder setDispatchReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + dispatchReceiver_ = value; + + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + public Builder setDispatchReceiver( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + dispatchReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + public Builder mergeDispatchReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (((bitField0_ & 0x00000020) == 0x00000020) && + dispatchReceiver_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance()) { + dispatchReceiver_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.newBuilder(dispatchReceiver_).mergeFrom(value).buildPartial(); + } else { + dispatchReceiver_ = value; + } + + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration dispatch_receiver = 6; + */ + public Builder clearDispatchReceiver() { + dispatchReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration extensionReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + public boolean hasExtensionReceiver() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getExtensionReceiver() { + return extensionReceiver_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + public Builder setExtensionReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + extensionReceiver_ = value; + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + public Builder setExtensionReceiver( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + extensionReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + public Builder mergeExtensionReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (((bitField0_ & 0x00000040) == 0x00000040) && + extensionReceiver_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance()) { + extensionReceiver_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.newBuilder(extensionReceiver_).mergeFrom(value).buildPartial(); + } else { + extensionReceiver_ = value; + } + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration extension_receiver = 7; + */ + public Builder clearExtensionReceiver() { + extensionReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + private java.util.List valueParameter_ = + java.util.Collections.emptyList(); + private void ensureValueParameterIsMutable() { + if (!((bitField0_ & 0x00000080) == 0x00000080)) { + valueParameter_ = new java.util.ArrayList(valueParameter_); + bitField0_ |= 0x00000080; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public java.util.List getValueParameterList() { + return java.util.Collections.unmodifiableList(valueParameter_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public int getValueParameterCount() { + return valueParameter_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getValueParameter(int index) { + return valueParameter_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public Builder setValueParameter( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueParameterIsMutable(); + valueParameter_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public Builder setValueParameter( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + ensureValueParameterIsMutable(); + valueParameter_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public Builder addValueParameter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueParameterIsMutable(); + valueParameter_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public Builder addValueParameter( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueParameterIsMutable(); + valueParameter_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public Builder addValueParameter( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + ensureValueParameterIsMutable(); + valueParameter_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public Builder addValueParameter( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + ensureValueParameterIsMutable(); + valueParameter_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public Builder addAllValueParameter( + java.lang.Iterable values) { + ensureValueParameterIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, valueParameter_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public Builder clearValueParameter() { + valueParameter_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration value_parameter = 8; + */ + public Builder removeValueParameter(int index) { + ensureValueParameterIsMutable(); + valueParameter_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getBody() { + return body_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + public Builder setBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + body_ = value; + + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + public Builder setBody( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + body_ = builderForValue.build(); + + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + public Builder mergeBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (((bitField0_ & 0x00000100) == 0x00000100) && + body_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance()) { + body_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.newBuilder(body_).mergeFrom(value).buildPartial(); + } else { + body_ = value; + } + + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 9; + */ + public Builder clearBody() { + body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000100); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex returnType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + public boolean hasReturnType() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getReturnType() { + return returnType_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + public Builder setReturnType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + returnType_ = value; + + bitField0_ |= 0x00000200; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + public Builder setReturnType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + returnType_ = builderForValue.build(); + + bitField0_ |= 0x00000200; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + public Builder mergeReturnType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000200) == 0x00000200) && + returnType_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + returnType_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(returnType_).mergeFrom(value).buildPartial(); + } else { + returnType_ = value; + } + + bitField0_ |= 0x00000200; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex return_type = 10; + */ + public Builder clearReturnType() { + returnType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000200); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase) + } + + static { + defaultInstance = new IrFunctionBase(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase) + } + + public interface IrConstructorOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrConstructor) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + boolean hasBase(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase getBase(); + + /** + * required bool is_primary = 3; + */ + boolean hasIsPrimary(); + /** + * required bool is_primary = 3; + */ + boolean getIsPrimary(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrConstructor} + */ + public static final class IrConstructor extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrConstructor) + IrConstructorOrBuilder { + // Use IrConstructor.newBuilder() to construct. + private IrConstructor(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrConstructor(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrConstructor defaultInstance; + public static IrConstructor getDefaultInstance() { + return defaultInstance; + } + + public IrConstructor getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrConstructor( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = base_.toBuilder(); + } + base_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(base_); + base_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 24: { + bitField0_ |= 0x00000004; + isPrimary_ = input.readBool(); + 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 IrConstructor parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrConstructor(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int BASE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase base_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public boolean hasBase() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase getBase() { + return base_; + } + + public static final int IS_PRIMARY_FIELD_NUMBER = 3; + private boolean isPrimary_; + /** + * required bool is_primary = 3; + */ + public boolean hasIsPrimary() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required bool is_primary = 3; + */ + public boolean getIsPrimary() { + return isPrimary_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + base_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance(); + isPrimary_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasBase()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsPrimary()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getBase().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, base_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBool(3, isPrimary_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, base_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(3, isPrimary_); + } + 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.KotlinIr.IrConstructor 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.KotlinIr.IrConstructor 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.KotlinIr.IrConstructor parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor 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.KotlinIr.IrConstructor parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor 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.KotlinIr.IrConstructor parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor 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.KotlinIr.IrConstructor parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor 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.KotlinIr.IrConstructor prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrConstructor} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrConstructor) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructorOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + base_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + isPrimary_ = false; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.base_ = base_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.isPrimary_ = isPrimary_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasBase()) { + mergeBase(other.getBase()); + } + if (other.hasIsPrimary()) { + setIsPrimary(other.getIsPrimary()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasBase()) { + + return false; + } + if (!hasIsPrimary()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getBase().isInitialized()) { + + 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.KotlinIr.IrConstructor parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase base_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public boolean hasBase() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase getBase() { + return base_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public Builder setBase(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase value) { + if (value == null) { + throw new NullPointerException(); + } + base_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public Builder setBase( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.Builder builderForValue) { + base_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public Builder mergeBase(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + base_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance()) { + base_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.newBuilder(base_).mergeFrom(value).buildPartial(); + } else { + base_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrFunctionBase base = 2; + */ + public Builder clearBase() { + base_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunctionBase.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private boolean isPrimary_ ; + /** + * required bool is_primary = 3; + */ + public boolean hasIsPrimary() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required bool is_primary = 3; + */ + public boolean getIsPrimary() { + return isPrimary_; + } + /** + * required bool is_primary = 3; + */ + public Builder setIsPrimary(boolean value) { + bitField0_ |= 0x00000004; + isPrimary_ = value; + + return this; + } + /** + * required bool is_primary = 3; + */ + public Builder clearIsPrimary() { + bitField0_ = (bitField0_ & ~0x00000004); + isPrimary_ = false; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrConstructor) + } + + static { + defaultInstance = new IrConstructor(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrConstructor) + } + + public interface IrFieldOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrField) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + boolean hasInitializer(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getInitializer(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + boolean hasVisibility(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility(); + + /** + * required bool is_final = 5; + */ + boolean hasIsFinal(); + /** + * required bool is_final = 5; + */ + boolean getIsFinal(); + + /** + * required bool is_external = 6; + */ + boolean hasIsExternal(); + /** + * required bool is_external = 6; + */ + boolean getIsExternal(); + + /** + * required bool is_static = 7; + */ + boolean hasIsStatic(); + /** + * required bool is_static = 7; + */ + boolean getIsStatic(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrField} + */ + public static final class IrField extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrField) + IrFieldOrBuilder { + // Use IrField.newBuilder() to construct. + private IrField(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrField(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrField defaultInstance; + public static IrField getDefaultInstance() { + return defaultInstance; + } + + public IrField getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrField( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = initializer_.toBuilder(); + } + initializer_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(initializer_); + initializer_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = visibility_.toBuilder(); + } + visibility_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(visibility_); + visibility_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 40: { + bitField0_ |= 0x00000010; + isFinal_ = input.readBool(); + break; + } + case 48: { + bitField0_ |= 0x00000020; + isExternal_ = input.readBool(); + break; + } + case 56: { + bitField0_ |= 0x00000040; + isStatic_ = input.readBool(); + break; + } + case 66: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(type_); + type_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000080; + 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 IrField parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrField(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int INITIALIZER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression initializer_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getInitializer() { + return initializer_; + } + + public static final int NAME_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + + public static final int VISIBILITY_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility visibility_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility() { + return visibility_; + } + + public static final int IS_FINAL_FIELD_NUMBER = 5; + private boolean isFinal_; + /** + * required bool is_final = 5; + */ + public boolean hasIsFinal() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required bool is_final = 5; + */ + public boolean getIsFinal() { + return isFinal_; + } + + public static final int IS_EXTERNAL_FIELD_NUMBER = 6; + private boolean isExternal_; + /** + * required bool is_external = 6; + */ + public boolean hasIsExternal() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_external = 6; + */ + public boolean getIsExternal() { + return isExternal_; + } + + public static final int IS_STATIC_FIELD_NUMBER = 7; + private boolean isStatic_; + /** + * required bool is_static = 7; + */ + public boolean hasIsStatic() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * required bool is_static = 7; + */ + public boolean getIsStatic() { + return isStatic_; + } + + public static final int TYPE_FIELD_NUMBER = 8; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + isFinal_ = false; + isExternal_ = false; + isStatic_ = false; + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasVisibility()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsFinal()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsExternal()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsStatic()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasInitializer()) { + if (!getInitializer().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getVisibility().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getType().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, initializer_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, name_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, visibility_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBool(5, isFinal_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeBool(6, isExternal_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeBool(7, isStatic_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeMessage(8, type_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, initializer_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, name_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, visibility_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(5, isFinal_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(6, isExternal_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(7, isStatic_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(8, type_); + } + 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.KotlinIr.IrField 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.KotlinIr.IrField 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.KotlinIr.IrField parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField 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.KotlinIr.IrField parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField 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.KotlinIr.IrField parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField 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.KotlinIr.IrField parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField 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.KotlinIr.IrField prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrField} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrField) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFieldOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + isFinal_ = false; + bitField0_ = (bitField0_ & ~0x00000010); + isExternal_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + isStatic_ = false; + bitField0_ = (bitField0_ & ~0x00000040); + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.initializer_ = initializer_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.visibility_ = visibility_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.isFinal_ = isFinal_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.isExternal_ = isExternal_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + result.isStatic_ = isStatic_; + if (((from_bitField0_ & 0x00000080) == 0x00000080)) { + to_bitField0_ |= 0x00000080; + } + result.type_ = type_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasInitializer()) { + mergeInitializer(other.getInitializer()); + } + if (other.hasName()) { + mergeName(other.getName()); + } + if (other.hasVisibility()) { + mergeVisibility(other.getVisibility()); + } + if (other.hasIsFinal()) { + setIsFinal(other.getIsFinal()); + } + if (other.hasIsExternal()) { + setIsExternal(other.getIsExternal()); + } + if (other.hasIsStatic()) { + setIsStatic(other.getIsStatic()); + } + if (other.hasType()) { + mergeType(other.getType()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasName()) { + + return false; + } + if (!hasVisibility()) { + + return false; + } + if (!hasIsFinal()) { + + return false; + } + if (!hasIsExternal()) { + + return false; + } + if (!hasIsStatic()) { + + return false; + } + if (!hasType()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (hasInitializer()) { + if (!getInitializer().isInitialized()) { + + return false; + } + } + if (!getName().isInitialized()) { + + return false; + } + if (!getVisibility().isInitialized()) { + + return false; + } + if (!getType().isInitialized()) { + + 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.KotlinIr.IrField parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getInitializer() { + return initializer_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public Builder setInitializer(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + initializer_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public Builder setInitializer( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + initializer_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public Builder mergeInitializer(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + initializer_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + initializer_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(initializer_).mergeFrom(value).buildPartial(); + } else { + initializer_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public Builder clearInitializer() { + initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 3; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility() { + return visibility_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public Builder setVisibility(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility value) { + if (value == null) { + throw new NullPointerException(); + } + visibility_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public Builder setVisibility( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.Builder builderForValue) { + visibility_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public Builder mergeVisibility(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + visibility_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance()) { + visibility_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.newBuilder(visibility_).mergeFrom(value).buildPartial(); + } else { + visibility_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public Builder clearVisibility() { + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private boolean isFinal_ ; + /** + * required bool is_final = 5; + */ + public boolean hasIsFinal() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required bool is_final = 5; + */ + public boolean getIsFinal() { + return isFinal_; + } + /** + * required bool is_final = 5; + */ + public Builder setIsFinal(boolean value) { + bitField0_ |= 0x00000010; + isFinal_ = value; + + return this; + } + /** + * required bool is_final = 5; + */ + public Builder clearIsFinal() { + bitField0_ = (bitField0_ & ~0x00000010); + isFinal_ = false; + + return this; + } + + private boolean isExternal_ ; + /** + * required bool is_external = 6; + */ + public boolean hasIsExternal() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_external = 6; + */ + public boolean getIsExternal() { + return isExternal_; + } + /** + * required bool is_external = 6; + */ + public Builder setIsExternal(boolean value) { + bitField0_ |= 0x00000020; + isExternal_ = value; + + return this; + } + /** + * required bool is_external = 6; + */ + public Builder clearIsExternal() { + bitField0_ = (bitField0_ & ~0x00000020); + isExternal_ = false; + + return this; + } + + private boolean isStatic_ ; + /** + * required bool is_static = 7; + */ + public boolean hasIsStatic() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * required bool is_static = 7; + */ + public boolean getIsStatic() { + return isStatic_; + } + /** + * required bool is_static = 7; + */ + public Builder setIsStatic(boolean value) { + bitField0_ |= 0x00000040; + isStatic_ = value; + + return this; + } + /** + * required bool is_static = 7; + */ + public Builder clearIsStatic() { + bitField0_ = (bitField0_ & ~0x00000040); + isStatic_ = false; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + public Builder setType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000080; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + public Builder setType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000080; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + public Builder mergeType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000080) == 0x00000080) && + type_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000080; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 8; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrField) + } + + static { + defaultInstance = new IrField(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrField) + } + + public interface IrPropertyOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrProperty) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + boolean hasDescriptorReference(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDescriptorReference(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + boolean hasVisibility(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 4; + */ + boolean hasModality(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind getModality(); + + /** + * required bool is_var = 5; + */ + boolean hasIsVar(); + /** + * required bool is_var = 5; + */ + boolean getIsVar(); + + /** + * required bool is_const = 6; + */ + boolean hasIsConst(); + /** + * required bool is_const = 6; + */ + boolean getIsConst(); + + /** + * required bool is_lateinit = 7; + */ + boolean hasIsLateinit(); + /** + * required bool is_lateinit = 7; + */ + boolean getIsLateinit(); + + /** + * required bool is_delegated = 8; + */ + boolean hasIsDelegated(); + /** + * required bool is_delegated = 8; + */ + boolean getIsDelegated(); + + /** + * required bool is_external = 9; + */ + boolean hasIsExternal(); + /** + * required bool is_external = 9; + */ + boolean getIsExternal(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + boolean hasBackingField(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField getBackingField(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + boolean hasGetter(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getGetter(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + boolean hasSetter(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getSetter(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrProperty} + */ + public static final class IrProperty extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrProperty) + IrPropertyOrBuilder { + // Use IrProperty.newBuilder() to construct. + private IrProperty(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrProperty(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrProperty defaultInstance; + public static IrProperty getDefaultInstance() { + return defaultInstance; + } + + public IrProperty getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrProperty( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = descriptorReference_.toBuilder(); + } + descriptorReference_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(descriptorReference_); + descriptorReference_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = visibility_.toBuilder(); + } + visibility_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(visibility_); + visibility_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 32: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000008; + modality_ = value; + } + break; + } + case 40: { + bitField0_ |= 0x00000010; + isVar_ = input.readBool(); + break; + } + case 48: { + bitField0_ |= 0x00000020; + isConst_ = input.readBool(); + break; + } + case 56: { + bitField0_ |= 0x00000040; + isLateinit_ = input.readBool(); + break; + } + case 64: { + bitField0_ |= 0x00000080; + isDelegated_ = input.readBool(); + break; + } + case 72: { + bitField0_ |= 0x00000100; + isExternal_ = input.readBool(); + break; + } + case 82: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.Builder subBuilder = null; + if (((bitField0_ & 0x00000200) == 0x00000200)) { + subBuilder = backingField_.toBuilder(); + } + backingField_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(backingField_); + backingField_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000200; + break; + } + case 90: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.Builder subBuilder = null; + if (((bitField0_ & 0x00000400) == 0x00000400)) { + subBuilder = getter_.toBuilder(); + } + getter_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(getter_); + getter_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000400; + break; + } + case 98: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.Builder subBuilder = null; + if (((bitField0_ & 0x00000800) == 0x00000800)) { + subBuilder = setter_.toBuilder(); + } + setter_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(setter_); + setter_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000800; + 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 IrProperty parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrProperty(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int DESCRIPTOR_REFERENCE_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference descriptorReference_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + public boolean hasDescriptorReference() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDescriptorReference() { + return descriptorReference_; + } + + public static final int NAME_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + + public static final int VISIBILITY_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility visibility_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility() { + return visibility_; + } + + public static final int MODALITY_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind modality_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 4; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind getModality() { + return modality_; + } + + public static final int IS_VAR_FIELD_NUMBER = 5; + private boolean isVar_; + /** + * required bool is_var = 5; + */ + public boolean hasIsVar() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required bool is_var = 5; + */ + public boolean getIsVar() { + return isVar_; + } + + public static final int IS_CONST_FIELD_NUMBER = 6; + private boolean isConst_; + /** + * required bool is_const = 6; + */ + public boolean hasIsConst() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_const = 6; + */ + public boolean getIsConst() { + return isConst_; + } + + public static final int IS_LATEINIT_FIELD_NUMBER = 7; + private boolean isLateinit_; + /** + * required bool is_lateinit = 7; + */ + public boolean hasIsLateinit() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * required bool is_lateinit = 7; + */ + public boolean getIsLateinit() { + return isLateinit_; + } + + public static final int IS_DELEGATED_FIELD_NUMBER = 8; + private boolean isDelegated_; + /** + * required bool is_delegated = 8; + */ + public boolean hasIsDelegated() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * required bool is_delegated = 8; + */ + public boolean getIsDelegated() { + return isDelegated_; + } + + public static final int IS_EXTERNAL_FIELD_NUMBER = 9; + private boolean isExternal_; + /** + * required bool is_external = 9; + */ + public boolean hasIsExternal() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * required bool is_external = 9; + */ + public boolean getIsExternal() { + return isExternal_; + } + + public static final int BACKING_FIELD_FIELD_NUMBER = 10; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField backingField_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + public boolean hasBackingField() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField getBackingField() { + return backingField_; + } + + public static final int GETTER_FIELD_NUMBER = 11; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getter_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + public boolean hasGetter() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getGetter() { + return getter_; + } + + public static final int SETTER_FIELD_NUMBER = 12; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction setter_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + public boolean hasSetter() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getSetter() { + return setter_; + } + + private void initFields() { + descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + isVar_ = false; + isConst_ = false; + isLateinit_ = false; + isDelegated_ = false; + isExternal_ = false; + backingField_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance(); + getter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + setter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasVisibility()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasModality()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsVar()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsConst()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsLateinit()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsDelegated()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsExternal()) { + memoizedIsInitialized = 0; + return false; + } + if (hasDescriptorReference()) { + if (!getDescriptorReference().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getVisibility().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasBackingField()) { + if (!getBackingField().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasGetter()) { + if (!getGetter().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasSetter()) { + if (!getSetter().isInitialized()) { + 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.writeMessage(1, descriptorReference_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, name_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, visibility_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeEnum(4, modality_.getNumber()); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBool(5, isVar_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeBool(6, isConst_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeBool(7, isLateinit_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeBool(8, isDelegated_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + output.writeBool(9, isExternal_); + } + if (((bitField0_ & 0x00000200) == 0x00000200)) { + output.writeMessage(10, backingField_); + } + if (((bitField0_ & 0x00000400) == 0x00000400)) { + output.writeMessage(11, getter_); + } + if (((bitField0_ & 0x00000800) == 0x00000800)) { + output.writeMessage(12, setter_); + } + 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 + .computeMessageSize(1, descriptorReference_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, name_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, visibility_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeEnumSize(4, modality_.getNumber()); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(5, isVar_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(6, isConst_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(7, isLateinit_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(8, isDelegated_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(9, isExternal_); + } + if (((bitField0_ & 0x00000200) == 0x00000200)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(10, backingField_); + } + if (((bitField0_ & 0x00000400) == 0x00000400)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(11, getter_); + } + if (((bitField0_ & 0x00000800) == 0x00000800)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(12, setter_); + } + 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.KotlinIr.IrProperty 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.KotlinIr.IrProperty 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.KotlinIr.IrProperty parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty 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.KotlinIr.IrProperty parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty 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.KotlinIr.IrProperty parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty 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.KotlinIr.IrProperty parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty 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.KotlinIr.IrProperty prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrProperty} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrProperty) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrPropertyOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + bitField0_ = (bitField0_ & ~0x00000008); + isVar_ = false; + bitField0_ = (bitField0_ & ~0x00000010); + isConst_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + isLateinit_ = false; + bitField0_ = (bitField0_ & ~0x00000040); + isDelegated_ = false; + bitField0_ = (bitField0_ & ~0x00000080); + isExternal_ = false; + bitField0_ = (bitField0_ & ~0x00000100); + backingField_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000200); + getter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000400); + setter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.descriptorReference_ = descriptorReference_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.visibility_ = visibility_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.modality_ = modality_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.isVar_ = isVar_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.isConst_ = isConst_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + result.isLateinit_ = isLateinit_; + if (((from_bitField0_ & 0x00000080) == 0x00000080)) { + to_bitField0_ |= 0x00000080; + } + result.isDelegated_ = isDelegated_; + if (((from_bitField0_ & 0x00000100) == 0x00000100)) { + to_bitField0_ |= 0x00000100; + } + result.isExternal_ = isExternal_; + if (((from_bitField0_ & 0x00000200) == 0x00000200)) { + to_bitField0_ |= 0x00000200; + } + result.backingField_ = backingField_; + if (((from_bitField0_ & 0x00000400) == 0x00000400)) { + to_bitField0_ |= 0x00000400; + } + result.getter_ = getter_; + if (((from_bitField0_ & 0x00000800) == 0x00000800)) { + to_bitField0_ |= 0x00000800; + } + result.setter_ = setter_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.getDefaultInstance()) return this; + if (other.hasDescriptorReference()) { + mergeDescriptorReference(other.getDescriptorReference()); + } + if (other.hasName()) { + mergeName(other.getName()); + } + if (other.hasVisibility()) { + mergeVisibility(other.getVisibility()); + } + if (other.hasModality()) { + setModality(other.getModality()); + } + if (other.hasIsVar()) { + setIsVar(other.getIsVar()); + } + if (other.hasIsConst()) { + setIsConst(other.getIsConst()); + } + if (other.hasIsLateinit()) { + setIsLateinit(other.getIsLateinit()); + } + if (other.hasIsDelegated()) { + setIsDelegated(other.getIsDelegated()); + } + if (other.hasIsExternal()) { + setIsExternal(other.getIsExternal()); + } + if (other.hasBackingField()) { + mergeBackingField(other.getBackingField()); + } + if (other.hasGetter()) { + mergeGetter(other.getGetter()); + } + if (other.hasSetter()) { + mergeSetter(other.getSetter()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!hasVisibility()) { + + return false; + } + if (!hasModality()) { + + return false; + } + if (!hasIsVar()) { + + return false; + } + if (!hasIsConst()) { + + return false; + } + if (!hasIsLateinit()) { + + return false; + } + if (!hasIsDelegated()) { + + return false; + } + if (!hasIsExternal()) { + + return false; + } + if (hasDescriptorReference()) { + if (!getDescriptorReference().isInitialized()) { + + return false; + } + } + if (!getName().isInitialized()) { + + return false; + } + if (!getVisibility().isInitialized()) { + + return false; + } + if (hasBackingField()) { + if (!getBackingField().isInitialized()) { + + return false; + } + } + if (hasGetter()) { + if (!getGetter().isInitialized()) { + + return false; + } + } + if (hasSetter()) { + if (!getSetter().isInitialized()) { + + 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.KotlinIr.IrProperty parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public boolean hasDescriptorReference() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference getDescriptorReference() { + return descriptorReference_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder setDescriptorReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference value) { + if (value == null) { + throw new NullPointerException(); + } + descriptorReference_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder setDescriptorReference( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.Builder builderForValue) { + descriptorReference_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder mergeDescriptorReference(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + descriptorReference_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance()) { + descriptorReference_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.newBuilder(descriptorReference_).mergeFrom(value).buildPartial(); + } else { + descriptorReference_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.DescriptorReference descriptor_reference = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder clearDescriptorReference() { + descriptorReference_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.DescriptorReference.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility() { + return visibility_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + public Builder setVisibility(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility value) { + if (value == null) { + throw new NullPointerException(); + } + visibility_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + public Builder setVisibility( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.Builder builderForValue) { + visibility_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + public Builder mergeVisibility(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + visibility_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance()) { + visibility_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.newBuilder(visibility_).mergeFrom(value).buildPartial(); + } else { + visibility_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 3; + */ + public Builder clearVisibility() { + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 4; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind getModality() { + return modality_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 4; + */ + public Builder setModality(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + modality_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 4; + */ + public Builder clearModality() { + bitField0_ = (bitField0_ & ~0x00000008); + modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + + return this; + } + + private boolean isVar_ ; + /** + * required bool is_var = 5; + */ + public boolean hasIsVar() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required bool is_var = 5; + */ + public boolean getIsVar() { + return isVar_; + } + /** + * required bool is_var = 5; + */ + public Builder setIsVar(boolean value) { + bitField0_ |= 0x00000010; + isVar_ = value; + + return this; + } + /** + * required bool is_var = 5; + */ + public Builder clearIsVar() { + bitField0_ = (bitField0_ & ~0x00000010); + isVar_ = false; + + return this; + } + + private boolean isConst_ ; + /** + * required bool is_const = 6; + */ + public boolean hasIsConst() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_const = 6; + */ + public boolean getIsConst() { + return isConst_; + } + /** + * required bool is_const = 6; + */ + public Builder setIsConst(boolean value) { + bitField0_ |= 0x00000020; + isConst_ = value; + + return this; + } + /** + * required bool is_const = 6; + */ + public Builder clearIsConst() { + bitField0_ = (bitField0_ & ~0x00000020); + isConst_ = false; + + return this; + } + + private boolean isLateinit_ ; + /** + * required bool is_lateinit = 7; + */ + public boolean hasIsLateinit() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * required bool is_lateinit = 7; + */ + public boolean getIsLateinit() { + return isLateinit_; + } + /** + * required bool is_lateinit = 7; + */ + public Builder setIsLateinit(boolean value) { + bitField0_ |= 0x00000040; + isLateinit_ = value; + + return this; + } + /** + * required bool is_lateinit = 7; + */ + public Builder clearIsLateinit() { + bitField0_ = (bitField0_ & ~0x00000040); + isLateinit_ = false; + + return this; + } + + private boolean isDelegated_ ; + /** + * required bool is_delegated = 8; + */ + public boolean hasIsDelegated() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * required bool is_delegated = 8; + */ + public boolean getIsDelegated() { + return isDelegated_; + } + /** + * required bool is_delegated = 8; + */ + public Builder setIsDelegated(boolean value) { + bitField0_ |= 0x00000080; + isDelegated_ = value; + + return this; + } + /** + * required bool is_delegated = 8; + */ + public Builder clearIsDelegated() { + bitField0_ = (bitField0_ & ~0x00000080); + isDelegated_ = false; + + return this; + } + + private boolean isExternal_ ; + /** + * required bool is_external = 9; + */ + public boolean hasIsExternal() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * required bool is_external = 9; + */ + public boolean getIsExternal() { + return isExternal_; + } + /** + * required bool is_external = 9; + */ + public Builder setIsExternal(boolean value) { + bitField0_ |= 0x00000100; + isExternal_ = value; + + return this; + } + /** + * required bool is_external = 9; + */ + public Builder clearIsExternal() { + bitField0_ = (bitField0_ & ~0x00000100); + isExternal_ = false; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField backingField_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + public boolean hasBackingField() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField getBackingField() { + return backingField_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + public Builder setBackingField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField value) { + if (value == null) { + throw new NullPointerException(); + } + backingField_ = value; + + bitField0_ |= 0x00000200; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + public Builder setBackingField( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.Builder builderForValue) { + backingField_ = builderForValue.build(); + + bitField0_ |= 0x00000200; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + public Builder mergeBackingField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField value) { + if (((bitField0_ & 0x00000200) == 0x00000200) && + backingField_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance()) { + backingField_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.newBuilder(backingField_).mergeFrom(value).buildPartial(); + } else { + backingField_ = value; + } + + bitField0_ |= 0x00000200; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField backing_field = 10; + */ + public Builder clearBackingField() { + backingField_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000200); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + public boolean hasGetter() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getGetter() { + return getter_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + public Builder setGetter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction value) { + if (value == null) { + throw new NullPointerException(); + } + getter_ = value; + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + public Builder setGetter( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.Builder builderForValue) { + getter_ = builderForValue.build(); + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + public Builder mergeGetter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction value) { + if (((bitField0_ & 0x00000400) == 0x00000400) && + getter_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance()) { + getter_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.newBuilder(getter_).mergeFrom(value).buildPartial(); + } else { + getter_ = value; + } + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction getter = 11; + */ + public Builder clearGetter() { + getter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000400); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction setter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + public boolean hasSetter() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getSetter() { + return setter_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + public Builder setSetter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction value) { + if (value == null) { + throw new NullPointerException(); + } + setter_ = value; + + bitField0_ |= 0x00000800; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + public Builder setSetter( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.Builder builderForValue) { + setter_ = builderForValue.build(); + + bitField0_ |= 0x00000800; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + public Builder mergeSetter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction value) { + if (((bitField0_ & 0x00000800) == 0x00000800) && + setter_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance()) { + setter_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.newBuilder(setter_).mergeFrom(value).buildPartial(); + } else { + setter_ = value; + } + + bitField0_ |= 0x00000800; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction setter = 12; + */ + public Builder clearSetter() { + setter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrProperty) + } + + static { + defaultInstance = new IrProperty(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrProperty) + } + + public interface IrVariableOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrVariable) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType(); + + /** + * required bool is_var = 4; + */ + boolean hasIsVar(); + /** + * required bool is_var = 4; + */ + boolean getIsVar(); + + /** + * required bool is_const = 5; + */ + boolean hasIsConst(); + /** + * required bool is_const = 5; + */ + boolean getIsConst(); + + /** + * required bool is_lateinit = 6; + */ + boolean hasIsLateinit(); + /** + * required bool is_lateinit = 6; + */ + boolean getIsLateinit(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + boolean hasInitializer(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getInitializer(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrVariable} + */ + public static final class IrVariable extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrVariable) + IrVariableOrBuilder { + // Use IrVariable.newBuilder() to construct. + private IrVariable(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrVariable(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrVariable defaultInstance; + public static IrVariable getDefaultInstance() { + return defaultInstance; + } + + public IrVariable getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrVariable( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(type_); + type_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 32: { + bitField0_ |= 0x00000008; + isVar_ = input.readBool(); + break; + } + case 40: { + bitField0_ |= 0x00000010; + isConst_ = input.readBool(); + break; + } + case 48: { + bitField0_ |= 0x00000020; + isLateinit_ = input.readBool(); + break; + } + case 58: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000040) == 0x00000040)) { + subBuilder = initializer_.toBuilder(); + } + initializer_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(initializer_); + initializer_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000040; + 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 IrVariable parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrVariable(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + + public static final int SYMBOL_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int TYPE_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + + public static final int IS_VAR_FIELD_NUMBER = 4; + private boolean isVar_; + /** + * required bool is_var = 4; + */ + public boolean hasIsVar() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required bool is_var = 4; + */ + public boolean getIsVar() { + return isVar_; + } + + public static final int IS_CONST_FIELD_NUMBER = 5; + private boolean isConst_; + /** + * required bool is_const = 5; + */ + public boolean hasIsConst() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required bool is_const = 5; + */ + public boolean getIsConst() { + return isConst_; + } + + public static final int IS_LATEINIT_FIELD_NUMBER = 6; + private boolean isLateinit_; + /** + * required bool is_lateinit = 6; + */ + public boolean hasIsLateinit() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_lateinit = 6; + */ + public boolean getIsLateinit() { + return isLateinit_; + } + + public static final int INITIALIZER_FIELD_NUMBER = 7; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression initializer_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getInitializer() { + return initializer_; + } + + private void initFields() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + isVar_ = false; + isConst_ = false; + isLateinit_ = false; + initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsVar()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsConst()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsLateinit()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getType().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasInitializer()) { + if (!getInitializer().isInitialized()) { + 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.writeMessage(1, name_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, symbol_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, type_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeBool(4, isVar_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBool(5, isConst_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeBool(6, isLateinit_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeMessage(7, initializer_); + } + 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 + .computeMessageSize(1, name_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, symbol_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, type_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(4, isVar_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(5, isConst_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(6, isLateinit_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(7, initializer_); + } + 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.KotlinIr.IrVariable 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.KotlinIr.IrVariable 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.KotlinIr.IrVariable parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable 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.KotlinIr.IrVariable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable 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.KotlinIr.IrVariable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable 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.KotlinIr.IrVariable parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable 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.KotlinIr.IrVariable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrVariable} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrVariable) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariableOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + isVar_ = false; + bitField0_ = (bitField0_ & ~0x00000008); + isConst_ = false; + bitField0_ = (bitField0_ & ~0x00000010); + isLateinit_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.isVar_ = isVar_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.isConst_ = isConst_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.isLateinit_ = isLateinit_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + result.initializer_ = initializer_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.getDefaultInstance()) return this; + if (other.hasName()) { + mergeName(other.getName()); + } + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasType()) { + mergeType(other.getType()); + } + if (other.hasIsVar()) { + setIsVar(other.getIsVar()); + } + if (other.hasIsConst()) { + setIsConst(other.getIsConst()); + } + if (other.hasIsLateinit()) { + setIsLateinit(other.getIsLateinit()); + } + if (other.hasInitializer()) { + mergeInitializer(other.getInitializer()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!hasSymbol()) { + + return false; + } + if (!hasType()) { + + return false; + } + if (!hasIsVar()) { + + return false; + } + if (!hasIsConst()) { + + return false; + } + if (!hasIsLateinit()) { + + return false; + } + if (!getName().isInitialized()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getType().isInitialized()) { + + return false; + } + if (hasInitializer()) { + if (!getInitializer().isInitialized()) { + + 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.KotlinIr.IrVariable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 1; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 2; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + public Builder setType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + public Builder setType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + public Builder mergeType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + type_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 3; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private boolean isVar_ ; + /** + * required bool is_var = 4; + */ + public boolean hasIsVar() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required bool is_var = 4; + */ + public boolean getIsVar() { + return isVar_; + } + /** + * required bool is_var = 4; + */ + public Builder setIsVar(boolean value) { + bitField0_ |= 0x00000008; + isVar_ = value; + + return this; + } + /** + * required bool is_var = 4; + */ + public Builder clearIsVar() { + bitField0_ = (bitField0_ & ~0x00000008); + isVar_ = false; + + return this; + } + + private boolean isConst_ ; + /** + * required bool is_const = 5; + */ + public boolean hasIsConst() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required bool is_const = 5; + */ + public boolean getIsConst() { + return isConst_; + } + /** + * required bool is_const = 5; + */ + public Builder setIsConst(boolean value) { + bitField0_ |= 0x00000010; + isConst_ = value; + + return this; + } + /** + * required bool is_const = 5; + */ + public Builder clearIsConst() { + bitField0_ = (bitField0_ & ~0x00000010); + isConst_ = false; + + return this; + } + + private boolean isLateinit_ ; + /** + * required bool is_lateinit = 6; + */ + public boolean hasIsLateinit() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_lateinit = 6; + */ + public boolean getIsLateinit() { + return isLateinit_; + } + /** + * required bool is_lateinit = 6; + */ + public Builder setIsLateinit(boolean value) { + bitField0_ |= 0x00000020; + isLateinit_ = value; + + return this; + } + /** + * required bool is_lateinit = 6; + */ + public Builder clearIsLateinit() { + bitField0_ = (bitField0_ & ~0x00000020); + isLateinit_ = false; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getInitializer() { + return initializer_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + public Builder setInitializer(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + initializer_ = value; + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + public Builder setInitializer( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + initializer_ = builderForValue.build(); + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + public Builder mergeInitializer(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000040) == 0x00000040) && + initializer_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + initializer_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(initializer_).mergeFrom(value).buildPartial(); + } else { + initializer_ = value; + } + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 7; + */ + public Builder clearInitializer() { + initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrVariable) + } + + static { + defaultInstance = new IrVariable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrVariable) + } + + public interface IrValueParameterOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrValueParameter) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName(); + + /** + * required int32 index = 3; + */ + boolean hasIndex(); + /** + * required int32 index = 3; + */ + int getIndex(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + boolean hasVarargElementType(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getVarargElementType(); + + /** + * required bool is_crossinline = 6; + */ + boolean hasIsCrossinline(); + /** + * required bool is_crossinline = 6; + */ + boolean getIsCrossinline(); + + /** + * required bool is_noinline = 7; + */ + boolean hasIsNoinline(); + /** + * required bool is_noinline = 7; + */ + boolean getIsNoinline(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + boolean hasDefaultValue(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getDefaultValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrValueParameter} + */ + public static final class IrValueParameter extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrValueParameter) + IrValueParameterOrBuilder { + // Use IrValueParameter.newBuilder() to construct. + private IrValueParameter(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrValueParameter(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrValueParameter defaultInstance; + public static IrValueParameter getDefaultInstance() { + return defaultInstance; + } + + public IrValueParameter getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrValueParameter( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 24: { + bitField0_ |= 0x00000004; + index_ = input.readInt32(); + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(type_); + type_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = varargElementType_.toBuilder(); + } + varargElementType_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(varargElementType_); + varargElementType_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + case 48: { + bitField0_ |= 0x00000020; + isCrossinline_ = input.readBool(); + break; + } + case 56: { + bitField0_ |= 0x00000040; + isNoinline_ = input.readBool(); + break; + } + case 66: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + subBuilder = defaultValue_.toBuilder(); + } + defaultValue_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(defaultValue_); + defaultValue_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000080; + 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 IrValueParameter parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrValueParameter(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int NAME_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + + public static final int INDEX_FIELD_NUMBER = 3; + private int index_; + /** + * required int32 index = 3; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 index = 3; + */ + public int getIndex() { + return index_; + } + + public static final int TYPE_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + + public static final int VARARG_ELEMENT_TYPE_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex varargElementType_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + public boolean hasVarargElementType() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getVarargElementType() { + return varargElementType_; + } + + public static final int IS_CROSSINLINE_FIELD_NUMBER = 6; + private boolean isCrossinline_; + /** + * required bool is_crossinline = 6; + */ + public boolean hasIsCrossinline() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_crossinline = 6; + */ + public boolean getIsCrossinline() { + return isCrossinline_; + } + + public static final int IS_NOINLINE_FIELD_NUMBER = 7; + private boolean isNoinline_; + /** + * required bool is_noinline = 7; + */ + public boolean hasIsNoinline() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * required bool is_noinline = 7; + */ + public boolean getIsNoinline() { + return isNoinline_; + } + + public static final int DEFAULT_VALUE_FIELD_NUMBER = 8; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression defaultValue_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + public boolean hasDefaultValue() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getDefaultValue() { + return defaultValue_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + index_ = 0; + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + varargElementType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + isCrossinline_ = false; + isNoinline_ = false; + defaultValue_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIndex()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsCrossinline()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsNoinline()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getType().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasVarargElementType()) { + if (!getVarargElementType().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDefaultValue()) { + if (!getDefaultValue().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, name_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt32(3, index_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, type_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(5, varargElementType_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeBool(6, isCrossinline_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeBool(7, isNoinline_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeMessage(8, defaultValue_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, name_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32Size(3, index_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, type_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, varargElementType_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(6, isCrossinline_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(7, isNoinline_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(8, defaultValue_); + } + 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.KotlinIr.IrValueParameter 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.KotlinIr.IrValueParameter 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.KotlinIr.IrValueParameter parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter 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.KotlinIr.IrValueParameter parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter 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.KotlinIr.IrValueParameter parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter 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.KotlinIr.IrValueParameter parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter 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.KotlinIr.IrValueParameter prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrValueParameter} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrValueParameter) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameterOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + index_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + varargElementType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); + isCrossinline_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + isNoinline_ = false; + bitField0_ = (bitField0_ & ~0x00000040); + defaultValue_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.index_ = index_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.varargElementType_ = varargElementType_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.isCrossinline_ = isCrossinline_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + result.isNoinline_ = isNoinline_; + if (((from_bitField0_ & 0x00000080) == 0x00000080)) { + to_bitField0_ |= 0x00000080; + } + result.defaultValue_ = defaultValue_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasName()) { + mergeName(other.getName()); + } + if (other.hasIndex()) { + setIndex(other.getIndex()); + } + if (other.hasType()) { + mergeType(other.getType()); + } + if (other.hasVarargElementType()) { + mergeVarargElementType(other.getVarargElementType()); + } + if (other.hasIsCrossinline()) { + setIsCrossinline(other.getIsCrossinline()); + } + if (other.hasIsNoinline()) { + setIsNoinline(other.getIsNoinline()); + } + if (other.hasDefaultValue()) { + mergeDefaultValue(other.getDefaultValue()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasName()) { + + return false; + } + if (!hasIndex()) { + + return false; + } + if (!hasType()) { + + return false; + } + if (!hasIsCrossinline()) { + + return false; + } + if (!hasIsNoinline()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getName().isInitialized()) { + + return false; + } + if (!getType().isInitialized()) { + + return false; + } + if (hasVarargElementType()) { + if (!getVarargElementType().isInitialized()) { + + return false; + } + } + if (hasDefaultValue()) { + if (!getDefaultValue().isInitialized()) { + + 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.KotlinIr.IrValueParameter parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private int index_ ; + /** + * required int32 index = 3; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 index = 3; + */ + public int getIndex() { + return index_; + } + /** + * required int32 index = 3; + */ + public Builder setIndex(int value) { + bitField0_ |= 0x00000004; + index_ = value; + + return this; + } + /** + * required int32 index = 3; + */ + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000004); + index_ = 0; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + public Builder setType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + public Builder setType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + public Builder mergeType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + type_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex type = 4; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex varargElementType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + public boolean hasVarargElementType() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getVarargElementType() { + return varargElementType_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + public Builder setVarargElementType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + varargElementType_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + public Builder setVarargElementType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + varargElementType_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + public Builder mergeVarargElementType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + varargElementType_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance()) { + varargElementType_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.newBuilder(varargElementType_).mergeFrom(value).buildPartial(); + } else { + varargElementType_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex vararg_element_type = 5; + */ + public Builder clearVarargElementType() { + varargElementType_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + private boolean isCrossinline_ ; + /** + * required bool is_crossinline = 6; + */ + public boolean hasIsCrossinline() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_crossinline = 6; + */ + public boolean getIsCrossinline() { + return isCrossinline_; + } + /** + * required bool is_crossinline = 6; + */ + public Builder setIsCrossinline(boolean value) { + bitField0_ |= 0x00000020; + isCrossinline_ = value; + + return this; + } + /** + * required bool is_crossinline = 6; + */ + public Builder clearIsCrossinline() { + bitField0_ = (bitField0_ & ~0x00000020); + isCrossinline_ = false; + + return this; + } + + private boolean isNoinline_ ; + /** + * required bool is_noinline = 7; + */ + public boolean hasIsNoinline() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * required bool is_noinline = 7; + */ + public boolean getIsNoinline() { + return isNoinline_; + } + /** + * required bool is_noinline = 7; + */ + public Builder setIsNoinline(boolean value) { + bitField0_ |= 0x00000040; + isNoinline_ = value; + + return this; + } + /** + * required bool is_noinline = 7; + */ + public Builder clearIsNoinline() { + bitField0_ = (bitField0_ & ~0x00000040); + isNoinline_ = false; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression defaultValue_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + public boolean hasDefaultValue() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getDefaultValue() { + return defaultValue_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + public Builder setDefaultValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + defaultValue_ = value; + + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + public Builder setDefaultValue( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + defaultValue_ = builderForValue.build(); + + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + public Builder mergeDefaultValue(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000080) == 0x00000080) && + defaultValue_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + defaultValue_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(defaultValue_).mergeFrom(value).buildPartial(); + } else { + defaultValue_ = value; + } + + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression default_value = 8; + */ + public Builder clearDefaultValue() { + defaultValue_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrValueParameter) + } + + static { + defaultInstance = new IrValueParameter(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrValueParameter) + } + + public interface IrTypeParameterOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName(); + + /** + * required int32 index = 3; + */ + boolean hasIndex(); + /** + * required int32 index = 3; + */ + int getIndex(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 4; + */ + boolean hasVariance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance getVariance(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + java.util.List + getSuperTypeList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getSuperType(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + int getSuperTypeCount(); + + /** + * required bool is_reified = 6; + */ + boolean hasIsReified(); + /** + * required bool is_reified = 6; + */ + boolean getIsReified(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter} + */ + public static final class IrTypeParameter extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter) + IrTypeParameterOrBuilder { + // Use IrTypeParameter.newBuilder() to construct. + private IrTypeParameter(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrTypeParameter(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrTypeParameter defaultInstance; + public static IrTypeParameter getDefaultInstance() { + return defaultInstance; + } + + public IrTypeParameter getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrTypeParameter( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 24: { + bitField0_ |= 0x00000004; + index_ = input.readInt32(); + break; + } + case 32: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000008; + variance_ = value; + } + break; + } + case 42: { + if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + superType_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000010; + } + superType_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry)); + break; + } + case 48: { + bitField0_ |= 0x00000010; + isReified_ = input.readBool(); + 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 { + if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + superType_ = java.util.Collections.unmodifiableList(superType_); + } + 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 IrTypeParameter parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrTypeParameter(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int NAME_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + + public static final int INDEX_FIELD_NUMBER = 3; + private int index_; + /** + * required int32 index = 3; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 index = 3; + */ + public int getIndex() { + return index_; + } + + public static final int VARIANCE_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance variance_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 4; + */ + public boolean hasVariance() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance getVariance() { + return variance_; + } + + public static final int SUPER_TYPE_FIELD_NUMBER = 5; + private java.util.List superType_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public java.util.List getSuperTypeList() { + return superType_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public java.util.List + getSuperTypeOrBuilderList() { + return superType_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public int getSuperTypeCount() { + return superType_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getSuperType(int index) { + return superType_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndexOrBuilder getSuperTypeOrBuilder( + int index) { + return superType_.get(index); + } + + public static final int IS_REIFIED_FIELD_NUMBER = 6; + private boolean isReified_; + /** + * required bool is_reified = 6; + */ + public boolean hasIsReified() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required bool is_reified = 6; + */ + public boolean getIsReified() { + return isReified_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + index_ = 0; + variance_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.IN; + superType_ = java.util.Collections.emptyList(); + isReified_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIndex()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasVariance()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsReified()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getSuperTypeCount(); i++) { + if (!getSuperType(i).isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, name_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt32(3, index_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeEnum(4, variance_.getNumber()); + } + for (int i = 0; i < superType_.size(); i++) { + output.writeMessage(5, superType_.get(i)); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBool(6, isReified_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, name_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeInt32Size(3, index_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeEnumSize(4, variance_.getNumber()); + } + for (int i = 0; i < superType_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, superType_.get(i)); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(6, isReified_); + } + 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.KotlinIr.IrTypeParameter 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.KotlinIr.IrTypeParameter 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.KotlinIr.IrTypeParameter parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter 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.KotlinIr.IrTypeParameter parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter 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.KotlinIr.IrTypeParameter parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter 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.KotlinIr.IrTypeParameter parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter 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.KotlinIr.IrTypeParameter prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + index_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + variance_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.IN; + bitField0_ = (bitField0_ & ~0x00000008); + superType_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + isReified_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.index_ = index_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.variance_ = variance_; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + superType_ = java.util.Collections.unmodifiableList(superType_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.superType_ = superType_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000010; + } + result.isReified_ = isReified_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasName()) { + mergeName(other.getName()); + } + if (other.hasIndex()) { + setIndex(other.getIndex()); + } + if (other.hasVariance()) { + setVariance(other.getVariance()); + } + if (!other.superType_.isEmpty()) { + if (superType_.isEmpty()) { + superType_ = other.superType_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureSuperTypeIsMutable(); + superType_.addAll(other.superType_); + } + + } + if (other.hasIsReified()) { + setIsReified(other.getIsReified()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasName()) { + + return false; + } + if (!hasIndex()) { + + return false; + } + if (!hasVariance()) { + + return false; + } + if (!hasIsReified()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getName().isInitialized()) { + + return false; + } + for (int i = 0; i < getSuperTypeCount(); i++) { + if (!getSuperType(i).isInitialized()) { + + 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.KotlinIr.IrTypeParameter parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private int index_ ; + /** + * required int32 index = 3; + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 index = 3; + */ + public int getIndex() { + return index_; + } + /** + * required int32 index = 3; + */ + public Builder setIndex(int value) { + bitField0_ |= 0x00000004; + index_ = value; + + return this; + } + /** + * required int32 index = 3; + */ + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000004); + index_ = 0; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance variance_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.IN; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 4; + */ + public boolean hasVariance() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance getVariance() { + return variance_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 4; + */ + public Builder setVariance(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + variance_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeVariance variance = 4; + */ + public Builder clearVariance() { + bitField0_ = (bitField0_ & ~0x00000008); + variance_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeVariance.IN; + + return this; + } + + private java.util.List superType_ = + java.util.Collections.emptyList(); + private void ensureSuperTypeIsMutable() { + if (!((bitField0_ & 0x00000010) == 0x00000010)) { + superType_ = new java.util.ArrayList(superType_); + bitField0_ |= 0x00000010; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public java.util.List getSuperTypeList() { + return java.util.Collections.unmodifiableList(superType_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public int getSuperTypeCount() { + return superType_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getSuperType(int index) { + return superType_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public Builder setSuperType( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public Builder setSuperType( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public Builder addSuperType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public Builder addSuperType( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public Builder addSuperType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public Builder addSuperType( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public Builder addAllSuperType( + java.lang.Iterable values) { + ensureSuperTypeIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, superType_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public Builder clearSuperType() { + superType_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 5; + */ + public Builder removeSuperType(int index) { + ensureSuperTypeIsMutable(); + superType_.remove(index); + + return this; + } + + private boolean isReified_ ; + /** + * required bool is_reified = 6; + */ + public boolean hasIsReified() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_reified = 6; + */ + public boolean getIsReified() { + return isReified_; + } + /** + * required bool is_reified = 6; + */ + public Builder setIsReified(boolean value) { + bitField0_ |= 0x00000020; + isReified_ = value; + + return this; + } + /** + * required bool is_reified = 6; + */ + public Builder clearIsReified() { + bitField0_ = (bitField0_ & ~0x00000020); + isReified_ = false; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter) + } + + static { + defaultInstance = new IrTypeParameter(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter) + } + + public interface IrTypeParameterContainerOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + java.util.List + getTypeParameterList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getTypeParameter(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + int getTypeParameterCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer} + */ + public static final class IrTypeParameterContainer extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer) + IrTypeParameterContainerOrBuilder { + // Use IrTypeParameterContainer.newBuilder() to construct. + private IrTypeParameterContainer(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrTypeParameterContainer(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrTypeParameterContainer defaultInstance; + public static IrTypeParameterContainer getDefaultInstance() { + return defaultInstance; + } + + public IrTypeParameterContainer getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrTypeParameterContainer( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + typeParameter_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + typeParameter_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + typeParameter_ = java.util.Collections.unmodifiableList(typeParameter_); + } + 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 IrTypeParameterContainer parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrTypeParameterContainer(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int TYPE_PARAMETER_FIELD_NUMBER = 1; + private java.util.List typeParameter_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public java.util.List getTypeParameterList() { + return typeParameter_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public java.util.List + getTypeParameterOrBuilderList() { + return typeParameter_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public int getTypeParameterCount() { + return typeParameter_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getTypeParameter(int index) { + return typeParameter_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrBuilder getTypeParameterOrBuilder( + int index) { + return typeParameter_.get(index); + } + + private void initFields() { + typeParameter_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getTypeParameterCount(); i++) { + if (!getTypeParameter(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < typeParameter_.size(); i++) { + output.writeMessage(1, typeParameter_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < typeParameter_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, typeParameter_.get(i)); + } + 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.KotlinIr.IrTypeParameterContainer 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.KotlinIr.IrTypeParameterContainer 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.KotlinIr.IrTypeParameterContainer parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer 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.KotlinIr.IrTypeParameterContainer parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer 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.KotlinIr.IrTypeParameterContainer parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer 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.KotlinIr.IrTypeParameterContainer parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer 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.KotlinIr.IrTypeParameterContainer prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainerOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + typeParameter_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + typeParameter_ = java.util.Collections.unmodifiableList(typeParameter_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.typeParameter_ = typeParameter_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance()) return this; + if (!other.typeParameter_.isEmpty()) { + if (typeParameter_.isEmpty()) { + typeParameter_ = other.typeParameter_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureTypeParameterIsMutable(); + typeParameter_.addAll(other.typeParameter_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getTypeParameterCount(); i++) { + if (!getTypeParameter(i).isInitialized()) { + + 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.KotlinIr.IrTypeParameterContainer parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List typeParameter_ = + java.util.Collections.emptyList(); + private void ensureTypeParameterIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + typeParameter_ = new java.util.ArrayList(typeParameter_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public java.util.List getTypeParameterList() { + return java.util.Collections.unmodifiableList(typeParameter_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public int getTypeParameterCount() { + return typeParameter_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getTypeParameter(int index) { + return typeParameter_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public Builder setTypeParameter( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeParameterIsMutable(); + typeParameter_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public Builder setTypeParameter( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + ensureTypeParameterIsMutable(); + typeParameter_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public Builder addTypeParameter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeParameterIsMutable(); + typeParameter_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public Builder addTypeParameter( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeParameterIsMutable(); + typeParameter_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public Builder addTypeParameter( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + ensureTypeParameterIsMutable(); + typeParameter_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public Builder addTypeParameter( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + ensureTypeParameterIsMutable(); + typeParameter_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public Builder addAllTypeParameter( + java.lang.Iterable values) { + ensureTypeParameterIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, typeParameter_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public Builder clearTypeParameter() { + typeParameter_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration type_parameter = 1; + */ + public Builder removeTypeParameter(int index) { + ensureTypeParameterIsMutable(); + typeParameter_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer) + } + + static { + defaultInstance = new IrTypeParameterContainer(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer) + } + + public interface IrClassOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrClass) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ClassKind kind = 3; + */ + boolean hasKind(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ClassKind kind = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind getKind(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + boolean hasVisibility(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 5; + */ + boolean hasModality(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind getModality(); + + /** + * required bool is_companion = 6; + * + * 
+     * TODO: consider using flags for the booleans.
+     *
+ */ + boolean hasIsCompanion(); + /** + * required bool is_companion = 6; + * + * 
+     * TODO: consider using flags for the booleans.
+     *
+ */ + boolean getIsCompanion(); + + /** + * required bool is_inner = 7; + */ + boolean hasIsInner(); + /** + * required bool is_inner = 7; + */ + boolean getIsInner(); + + /** + * required bool is_data = 8; + */ + boolean hasIsData(); + /** + * required bool is_data = 8; + */ + boolean getIsData(); + + /** + * required bool is_external = 9; + */ + boolean hasIsExternal(); + /** + * required bool is_external = 9; + */ + boolean getIsExternal(); + + /** + * required bool is_inline = 10; + */ + boolean hasIsInline(); + /** + * required bool is_inline = 10; + */ + boolean getIsInline(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + boolean hasThisReceiver(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getThisReceiver(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + boolean hasTypeParameters(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer getTypeParameters(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + boolean hasDeclarationContainer(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer getDeclarationContainer(); + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + java.util.List + getSuperTypeList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getSuperType(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + int getSuperTypeCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrClass} + */ + public static final class IrClass extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrClass) + IrClassOrBuilder { + // Use IrClass.newBuilder() to construct. + private IrClass(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrClass(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrClass defaultInstance; + public static IrClass getDefaultInstance() { + return defaultInstance; + } + + public IrClass getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrClass( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 24: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000004; + kind_ = value; + } + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = visibility_.toBuilder(); + } + visibility_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(visibility_); + visibility_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 40: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000010; + modality_ = value; + } + break; + } + case 48: { + bitField0_ |= 0x00000020; + isCompanion_ = input.readBool(); + break; + } + case 56: { + bitField0_ |= 0x00000040; + isInner_ = input.readBool(); + break; + } + case 64: { + bitField0_ |= 0x00000080; + isData_ = input.readBool(); + break; + } + case 72: { + bitField0_ |= 0x00000100; + isExternal_ = input.readBool(); + break; + } + case 80: { + bitField0_ |= 0x00000200; + isInline_ = input.readBool(); + break; + } + case 90: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000400) == 0x00000400)) { + subBuilder = thisReceiver_.toBuilder(); + } + thisReceiver_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(thisReceiver_); + thisReceiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000400; + break; + } + case 98: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.Builder subBuilder = null; + if (((bitField0_ & 0x00000800) == 0x00000800)) { + subBuilder = typeParameters_.toBuilder(); + } + typeParameters_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(typeParameters_); + typeParameters_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000800; + break; + } + case 106: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.Builder subBuilder = null; + if (((bitField0_ & 0x00001000) == 0x00001000)) { + subBuilder = declarationContainer_.toBuilder(); + } + declarationContainer_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(declarationContainer_); + declarationContainer_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00001000; + break; + } + case 114: { + if (!((mutable_bitField0_ & 0x00002000) == 0x00002000)) { + superType_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00002000; + } + superType_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00002000) == 0x00002000)) { + superType_ = java.util.Collections.unmodifiableList(superType_); + } + 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 IrClass parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrClass(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int NAME_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + + public static final int KIND_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind kind_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ClassKind kind = 3; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ClassKind kind = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind getKind() { + return kind_; + } + + public static final int VISIBILITY_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility visibility_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility() { + return visibility_; + } + + public static final int MODALITY_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind modality_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 5; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind getModality() { + return modality_; + } + + public static final int IS_COMPANION_FIELD_NUMBER = 6; + private boolean isCompanion_; + /** + * required bool is_companion = 6; + * + * 
+     * TODO: consider using flags for the booleans.
+     *
+ */ + public boolean hasIsCompanion() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_companion = 6; + * + * 
+     * TODO: consider using flags for the booleans.
+     *
+ */ + public boolean getIsCompanion() { + return isCompanion_; + } + + public static final int IS_INNER_FIELD_NUMBER = 7; + private boolean isInner_; + /** + * required bool is_inner = 7; + */ + public boolean hasIsInner() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * required bool is_inner = 7; + */ + public boolean getIsInner() { + return isInner_; + } + + public static final int IS_DATA_FIELD_NUMBER = 8; + private boolean isData_; + /** + * required bool is_data = 8; + */ + public boolean hasIsData() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * required bool is_data = 8; + */ + public boolean getIsData() { + return isData_; + } + + public static final int IS_EXTERNAL_FIELD_NUMBER = 9; + private boolean isExternal_; + /** + * required bool is_external = 9; + */ + public boolean hasIsExternal() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * required bool is_external = 9; + */ + public boolean getIsExternal() { + return isExternal_; + } + + public static final int IS_INLINE_FIELD_NUMBER = 10; + private boolean isInline_; + /** + * required bool is_inline = 10; + */ + public boolean hasIsInline() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * required bool is_inline = 10; + */ + public boolean getIsInline() { + return isInline_; + } + + public static final int THIS_RECEIVER_FIELD_NUMBER = 11; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration thisReceiver_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + public boolean hasThisReceiver() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getThisReceiver() { + return thisReceiver_; + } + + public static final int TYPE_PARAMETERS_FIELD_NUMBER = 12; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer typeParameters_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + public boolean hasTypeParameters() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer getTypeParameters() { + return typeParameters_; + } + + public static final int DECLARATION_CONTAINER_FIELD_NUMBER = 13; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer declarationContainer_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + public boolean hasDeclarationContainer() { + return ((bitField0_ & 0x00001000) == 0x00001000); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer getDeclarationContainer() { + return declarationContainer_; + } + + public static final int SUPER_TYPE_FIELD_NUMBER = 14; + private java.util.List superType_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public java.util.List getSuperTypeList() { + return superType_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public java.util.List + getSuperTypeOrBuilderList() { + return superType_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public int getSuperTypeCount() { + return superType_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getSuperType(int index) { + return superType_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndexOrBuilder getSuperTypeOrBuilder( + int index) { + return superType_.get(index); + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind.CLASS; + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + isCompanion_ = false; + isInner_ = false; + isData_ = false; + isExternal_ = false; + isInline_ = false; + thisReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + typeParameters_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance(); + declarationContainer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.getDefaultInstance(); + superType_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasKind()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasVisibility()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasModality()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsCompanion()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsInner()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsData()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsExternal()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasIsInline()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasTypeParameters()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasDeclarationContainer()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getVisibility().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasThisReceiver()) { + if (!getThisReceiver().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getTypeParameters().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getDeclarationContainer().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getSuperTypeCount(); i++) { + if (!getSuperType(i).isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, name_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeEnum(3, kind_.getNumber()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, visibility_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeEnum(5, modality_.getNumber()); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeBool(6, isCompanion_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeBool(7, isInner_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeBool(8, isData_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + output.writeBool(9, isExternal_); + } + if (((bitField0_ & 0x00000200) == 0x00000200)) { + output.writeBool(10, isInline_); + } + if (((bitField0_ & 0x00000400) == 0x00000400)) { + output.writeMessage(11, thisReceiver_); + } + if (((bitField0_ & 0x00000800) == 0x00000800)) { + output.writeMessage(12, typeParameters_); + } + if (((bitField0_ & 0x00001000) == 0x00001000)) { + output.writeMessage(13, declarationContainer_); + } + for (int i = 0; i < superType_.size(); i++) { + output.writeMessage(14, superType_.get(i)); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, name_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeEnumSize(3, kind_.getNumber()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, visibility_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeEnumSize(5, modality_.getNumber()); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(6, isCompanion_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(7, isInner_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(8, isData_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(9, isExternal_); + } + if (((bitField0_ & 0x00000200) == 0x00000200)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBoolSize(10, isInline_); + } + if (((bitField0_ & 0x00000400) == 0x00000400)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(11, thisReceiver_); + } + if (((bitField0_ & 0x00000800) == 0x00000800)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(12, typeParameters_); + } + if (((bitField0_ & 0x00001000) == 0x00001000)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(13, declarationContainer_); + } + for (int i = 0; i < superType_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(14, superType_.get(i)); + } + 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.KotlinIr.IrClass 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.KotlinIr.IrClass 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.KotlinIr.IrClass parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass 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.KotlinIr.IrClass parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass 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.KotlinIr.IrClass parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass 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.KotlinIr.IrClass parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass 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.KotlinIr.IrClass prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrClass} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrClass) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClassOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind.CLASS; + bitField0_ = (bitField0_ & ~0x00000004); + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + bitField0_ = (bitField0_ & ~0x00000010); + isCompanion_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + isInner_ = false; + bitField0_ = (bitField0_ & ~0x00000040); + isData_ = false; + bitField0_ = (bitField0_ & ~0x00000080); + isExternal_ = false; + bitField0_ = (bitField0_ & ~0x00000100); + isInline_ = false; + bitField0_ = (bitField0_ & ~0x00000200); + thisReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000400); + typeParameters_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000800); + declarationContainer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00001000); + superType_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00002000); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.kind_ = kind_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.visibility_ = visibility_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.modality_ = modality_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.isCompanion_ = isCompanion_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + result.isInner_ = isInner_; + if (((from_bitField0_ & 0x00000080) == 0x00000080)) { + to_bitField0_ |= 0x00000080; + } + result.isData_ = isData_; + if (((from_bitField0_ & 0x00000100) == 0x00000100)) { + to_bitField0_ |= 0x00000100; + } + result.isExternal_ = isExternal_; + if (((from_bitField0_ & 0x00000200) == 0x00000200)) { + to_bitField0_ |= 0x00000200; + } + result.isInline_ = isInline_; + if (((from_bitField0_ & 0x00000400) == 0x00000400)) { + to_bitField0_ |= 0x00000400; + } + result.thisReceiver_ = thisReceiver_; + if (((from_bitField0_ & 0x00000800) == 0x00000800)) { + to_bitField0_ |= 0x00000800; + } + result.typeParameters_ = typeParameters_; + if (((from_bitField0_ & 0x00001000) == 0x00001000)) { + to_bitField0_ |= 0x00001000; + } + result.declarationContainer_ = declarationContainer_; + if (((bitField0_ & 0x00002000) == 0x00002000)) { + superType_ = java.util.Collections.unmodifiableList(superType_); + bitField0_ = (bitField0_ & ~0x00002000); + } + result.superType_ = superType_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasName()) { + mergeName(other.getName()); + } + if (other.hasKind()) { + setKind(other.getKind()); + } + if (other.hasVisibility()) { + mergeVisibility(other.getVisibility()); + } + if (other.hasModality()) { + setModality(other.getModality()); + } + if (other.hasIsCompanion()) { + setIsCompanion(other.getIsCompanion()); + } + if (other.hasIsInner()) { + setIsInner(other.getIsInner()); + } + if (other.hasIsData()) { + setIsData(other.getIsData()); + } + if (other.hasIsExternal()) { + setIsExternal(other.getIsExternal()); + } + if (other.hasIsInline()) { + setIsInline(other.getIsInline()); + } + if (other.hasThisReceiver()) { + mergeThisReceiver(other.getThisReceiver()); + } + if (other.hasTypeParameters()) { + mergeTypeParameters(other.getTypeParameters()); + } + if (other.hasDeclarationContainer()) { + mergeDeclarationContainer(other.getDeclarationContainer()); + } + if (!other.superType_.isEmpty()) { + if (superType_.isEmpty()) { + superType_ = other.superType_; + bitField0_ = (bitField0_ & ~0x00002000); + } else { + ensureSuperTypeIsMutable(); + superType_.addAll(other.superType_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasName()) { + + return false; + } + if (!hasKind()) { + + return false; + } + if (!hasVisibility()) { + + return false; + } + if (!hasModality()) { + + return false; + } + if (!hasIsCompanion()) { + + return false; + } + if (!hasIsInner()) { + + return false; + } + if (!hasIsData()) { + + return false; + } + if (!hasIsExternal()) { + + return false; + } + if (!hasIsInline()) { + + return false; + } + if (!hasTypeParameters()) { + + return false; + } + if (!hasDeclarationContainer()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getName().isInitialized()) { + + return false; + } + if (!getVisibility().isInitialized()) { + + return false; + } + if (hasThisReceiver()) { + if (!getThisReceiver().isInitialized()) { + + return false; + } + } + if (!getTypeParameters().isInitialized()) { + + return false; + } + if (!getDeclarationContainer().isInitialized()) { + + return false; + } + for (int i = 0; i < getSuperTypeCount(); i++) { + if (!getSuperType(i).isInitialized()) { + + 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.KotlinIr.IrClass parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 2; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind.CLASS; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ClassKind kind = 3; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ClassKind kind = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind getKind() { + return kind_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ClassKind kind = 3; + */ + public Builder setKind(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + kind_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ClassKind kind = 3; + */ + public Builder clearKind() { + bitField0_ = (bitField0_ & ~0x00000004); + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ClassKind.CLASS; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility getVisibility() { + return visibility_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public Builder setVisibility(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility value) { + if (value == null) { + throw new NullPointerException(); + } + visibility_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public Builder setVisibility( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.Builder builderForValue) { + visibility_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public Builder mergeVisibility(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + visibility_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance()) { + visibility_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.newBuilder(visibility_).mergeFrom(value).buildPartial(); + } else { + visibility_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Visibility visibility = 4; + */ + public Builder clearVisibility() { + visibility_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Visibility.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 5; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind getModality() { + return modality_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 5; + */ + public Builder setModality(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + modality_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.ModalityKind modality = 5; + */ + public Builder clearModality() { + bitField0_ = (bitField0_ & ~0x00000010); + modality_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.ModalityKind.FINAL_MODALITY; + + return this; + } + + private boolean isCompanion_ ; + /** + * required bool is_companion = 6; + * + * 
+       * TODO: consider using flags for the booleans.
+       *
+ */ + public boolean hasIsCompanion() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required bool is_companion = 6; + * + * 
+       * TODO: consider using flags for the booleans.
+       *
+ */ + public boolean getIsCompanion() { + return isCompanion_; + } + /** + * required bool is_companion = 6; + * + * 
+       * TODO: consider using flags for the booleans.
+       *
+ */ + public Builder setIsCompanion(boolean value) { + bitField0_ |= 0x00000020; + isCompanion_ = value; + + return this; + } + /** + * required bool is_companion = 6; + * + * 
+       * TODO: consider using flags for the booleans.
+       *
+ */ + public Builder clearIsCompanion() { + bitField0_ = (bitField0_ & ~0x00000020); + isCompanion_ = false; + + return this; + } + + private boolean isInner_ ; + /** + * required bool is_inner = 7; + */ + public boolean hasIsInner() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * required bool is_inner = 7; + */ + public boolean getIsInner() { + return isInner_; + } + /** + * required bool is_inner = 7; + */ + public Builder setIsInner(boolean value) { + bitField0_ |= 0x00000040; + isInner_ = value; + + return this; + } + /** + * required bool is_inner = 7; + */ + public Builder clearIsInner() { + bitField0_ = (bitField0_ & ~0x00000040); + isInner_ = false; + + return this; + } + + private boolean isData_ ; + /** + * required bool is_data = 8; + */ + public boolean hasIsData() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * required bool is_data = 8; + */ + public boolean getIsData() { + return isData_; + } + /** + * required bool is_data = 8; + */ + public Builder setIsData(boolean value) { + bitField0_ |= 0x00000080; + isData_ = value; + + return this; + } + /** + * required bool is_data = 8; + */ + public Builder clearIsData() { + bitField0_ = (bitField0_ & ~0x00000080); + isData_ = false; + + return this; + } + + private boolean isExternal_ ; + /** + * required bool is_external = 9; + */ + public boolean hasIsExternal() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * required bool is_external = 9; + */ + public boolean getIsExternal() { + return isExternal_; + } + /** + * required bool is_external = 9; + */ + public Builder setIsExternal(boolean value) { + bitField0_ |= 0x00000100; + isExternal_ = value; + + return this; + } + /** + * required bool is_external = 9; + */ + public Builder clearIsExternal() { + bitField0_ = (bitField0_ & ~0x00000100); + isExternal_ = false; + + return this; + } + + private boolean isInline_ ; + /** + * required bool is_inline = 10; + */ + public boolean hasIsInline() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * required bool is_inline = 10; + */ + public boolean getIsInline() { + return isInline_; + } + /** + * required bool is_inline = 10; + */ + public Builder setIsInline(boolean value) { + bitField0_ |= 0x00000200; + isInline_ = value; + + return this; + } + /** + * required bool is_inline = 10; + */ + public Builder clearIsInline() { + bitField0_ = (bitField0_ & ~0x00000200); + isInline_ = false; + + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration thisReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + public boolean hasThisReceiver() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getThisReceiver() { + return thisReceiver_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + public Builder setThisReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + thisReceiver_ = value; + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + public Builder setThisReceiver( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + thisReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + public Builder mergeThisReceiver(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (((bitField0_ & 0x00000400) == 0x00000400) && + thisReceiver_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance()) { + thisReceiver_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.newBuilder(thisReceiver_).mergeFrom(value).buildPartial(); + } else { + thisReceiver_ = value; + } + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration this_receiver = 11; + */ + public Builder clearThisReceiver() { + thisReceiver_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000400); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer typeParameters_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + public boolean hasTypeParameters() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer getTypeParameters() { + return typeParameters_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + public Builder setTypeParameters(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer value) { + if (value == null) { + throw new NullPointerException(); + } + typeParameters_ = value; + + bitField0_ |= 0x00000800; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + public Builder setTypeParameters( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.Builder builderForValue) { + typeParameters_ = builderForValue.build(); + + bitField0_ |= 0x00000800; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + public Builder mergeTypeParameters(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer value) { + if (((bitField0_ & 0x00000800) == 0x00000800) && + typeParameters_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance()) { + typeParameters_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.newBuilder(typeParameters_).mergeFrom(value).buildPartial(); + } else { + typeParameters_ = value; + } + + bitField0_ |= 0x00000800; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameterContainer type_parameters = 12; + */ + public Builder clearTypeParameters() { + typeParameters_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameterContainer.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer declarationContainer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + public boolean hasDeclarationContainer() { + return ((bitField0_ & 0x00001000) == 0x00001000); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer getDeclarationContainer() { + return declarationContainer_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + public Builder setDeclarationContainer(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer value) { + if (value == null) { + throw new NullPointerException(); + } + declarationContainer_ = value; + + bitField0_ |= 0x00001000; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + public Builder setDeclarationContainer( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.Builder builderForValue) { + declarationContainer_ = builderForValue.build(); + + bitField0_ |= 0x00001000; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + public Builder mergeDeclarationContainer(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer value) { + if (((bitField0_ & 0x00001000) == 0x00001000) && + declarationContainer_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.getDefaultInstance()) { + declarationContainer_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.newBuilder(declarationContainer_).mergeFrom(value).buildPartial(); + } else { + declarationContainer_ = value; + } + + bitField0_ |= 0x00001000; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationContainer declaration_container = 13; + */ + public Builder clearDeclarationContainer() { + declarationContainer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationContainer.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00001000); + return this; + } + + private java.util.List superType_ = + java.util.Collections.emptyList(); + private void ensureSuperTypeIsMutable() { + if (!((bitField0_ & 0x00002000) == 0x00002000)) { + superType_ = new java.util.ArrayList(superType_); + bitField0_ |= 0x00002000; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public java.util.List getSuperTypeList() { + return java.util.Collections.unmodifiableList(superType_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public int getSuperTypeCount() { + return superType_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex getSuperType(int index) { + return superType_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public Builder setSuperType( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public Builder setSuperType( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public Builder addSuperType(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public Builder addSuperType( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public Builder addSuperType( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public Builder addSuperType( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public Builder addAllSuperType( + java.lang.Iterable values) { + ensureSuperTypeIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, superType_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public Builder clearSuperType() { + superType_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00002000); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrTypeIndex super_type = 14; + */ + public Builder removeSuperType(int index) { + ensureSuperTypeIsMutable(); + superType_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrClass) + } + + static { + defaultInstance = new IrClass(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrClass) + } + + public interface IrEnumEntryOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + boolean hasInitializer(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getInitializer(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + boolean hasCorrespondingClass(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getCorrespondingClass(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + boolean hasName(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry} + */ + public static final class IrEnumEntry extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry) + IrEnumEntryOrBuilder { + // Use IrEnumEntry.newBuilder() to construct. + private IrEnumEntry(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrEnumEntry(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrEnumEntry defaultInstance; + public static IrEnumEntry getDefaultInstance() { + return defaultInstance; + } + + public IrEnumEntry getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrEnumEntry( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = initializer_.toBuilder(); + } + initializer_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(initializer_); + initializer_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = correspondingClass_.toBuilder(); + } + correspondingClass_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(correspondingClass_); + correspondingClass_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + 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 IrEnumEntry parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrEnumEntry(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int INITIALIZER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression initializer_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getInitializer() { + return initializer_; + } + + public static final int CORRESPONDING_CLASS_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration correspondingClass_; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + public boolean hasCorrespondingClass() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getCorrespondingClass() { + return correspondingClass_; + } + + public static final int NAME_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + correspondingClass_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasInitializer()) { + if (!getInitializer().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasCorrespondingClass()) { + if (!getCorrespondingClass().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getName().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, initializer_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, correspondingClass_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, name_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, initializer_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, correspondingClass_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, name_); + } + 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.KotlinIr.IrEnumEntry 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.KotlinIr.IrEnumEntry 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.KotlinIr.IrEnumEntry parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry 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.KotlinIr.IrEnumEntry parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry 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.KotlinIr.IrEnumEntry parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry 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.KotlinIr.IrEnumEntry parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry 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.KotlinIr.IrEnumEntry prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntryOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + correspondingClass_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.initializer_ = initializer_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.correspondingClass_ = correspondingClass_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.name_ = name_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasInitializer()) { + mergeInitializer(other.getInitializer()); + } + if (other.hasCorrespondingClass()) { + mergeCorrespondingClass(other.getCorrespondingClass()); + } + if (other.hasName()) { + mergeName(other.getName()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasName()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (hasInitializer()) { + if (!getInitializer().isInitialized()) { + + return false; + } + } + if (hasCorrespondingClass()) { + if (!getCorrespondingClass().isInitialized()) { + + return false; + } + } + if (!getName().isInitialized()) { + + 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.KotlinIr.IrEnumEntry parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getInitializer() { + return initializer_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public Builder setInitializer(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + initializer_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public Builder setInitializer( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + initializer_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public Builder mergeInitializer(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + initializer_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + initializer_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(initializer_).mergeFrom(value).buildPartial(); + } else { + initializer_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression initializer = 2; + */ + public Builder clearInitializer() { + initializer_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration correspondingClass_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + public boolean hasCorrespondingClass() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getCorrespondingClass() { + return correspondingClass_; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + public Builder setCorrespondingClass(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + correspondingClass_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + public Builder setCorrespondingClass( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + correspondingClass_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + public Builder mergeCorrespondingClass(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + correspondingClass_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance()) { + correspondingClass_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.newBuilder(correspondingClass_).mergeFrom(value).buildPartial(); + } else { + correspondingClass_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration corresponding_class = 3; + */ + public Builder clearCorrespondingClass() { + correspondingClass_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name getName() { + return name_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + public Builder setName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + public Builder setName( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.Builder builderForValue) { + name_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + public Builder mergeName(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + name_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance()) { + name_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Name name = 4; + */ + public Builder clearName() { + name_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Name.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry) + } + + static { + defaultInstance = new IrEnumEntry(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry) + } + + public interface IrAnonymousInitOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + boolean hasBody(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getBody(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit} + */ + public static final class IrAnonymousInit extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit) + IrAnonymousInitOrBuilder { + // Use IrAnonymousInit.newBuilder() to construct. + private IrAnonymousInit(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrAnonymousInit(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrAnonymousInit defaultInstance; + public static IrAnonymousInit getDefaultInstance() { + return defaultInstance; + } + + public IrAnonymousInit getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrAnonymousInit( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = body_.toBuilder(); + } + body_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(body_); + body_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrAnonymousInit parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrAnonymousInit(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int SYMBOL_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + + public static final int BODY_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement body_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getBody() { + return body_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSymbol()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasBody()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSymbol().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getBody().isInitialized()) { + 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.writeMessage(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, body_); + } + 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 + .computeMessageSize(1, symbol_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, body_); + } + 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.KotlinIr.IrAnonymousInit 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.KotlinIr.IrAnonymousInit 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.KotlinIr.IrAnonymousInit parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit 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.KotlinIr.IrAnonymousInit parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit 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.KotlinIr.IrAnonymousInit parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit 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.KotlinIr.IrAnonymousInit parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit 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.KotlinIr.IrAnonymousInit prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInitOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.body_ = body_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasBody()) { + mergeBody(other.getBody()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasSymbol()) { + + return false; + } + if (!hasBody()) { + + return false; + } + if (!getSymbol().isInitialized()) { + + return false; + } + if (!getBody().isInitialized()) { + + 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.KotlinIr.IrAnonymousInit parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getBody() { + return body_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + public Builder setBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + body_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + public Builder setBody( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + body_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + public Builder mergeBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + body_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance()) { + body_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.newBuilder(body_).mergeFrom(value).buildPartial(); + } else { + body_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatement body = 2; + */ + public Builder clearBody() { + body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit) + } + + static { + defaultInstance = new IrAnonymousInit(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit) + } + + public interface IrDeclaratorOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrDeclarator) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + boolean hasIrAnonymousInit(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit getIrAnonymousInit(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + boolean hasIrClass(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass getIrClass(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + boolean hasIrConstructor(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor getIrConstructor(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + boolean hasIrEnumEntry(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry getIrEnumEntry(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + boolean hasIrField(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField getIrField(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + boolean hasIrFunction(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getIrFunction(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + boolean hasIrProperty(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty getIrProperty(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + boolean hasIrTypeAlias(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias getIrTypeAlias(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + boolean hasIrTypeParameter(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter getIrTypeParameter(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + boolean hasIrVariable(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable getIrVariable(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + boolean hasIrValueParameter(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter getIrValueParameter(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDeclarator} + * + * 
+   * TODO: we need an extension mechanism to accomodate new
+   * IR operators in upcoming releases.
+   *
+ */ + public static final class IrDeclarator extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrDeclarator) + IrDeclaratorOrBuilder { + // Use IrDeclarator.newBuilder() to construct. + private IrDeclarator(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDeclarator(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDeclarator defaultInstance; + public static IrDeclarator getDefaultInstance() { + return defaultInstance; + } + + public IrDeclarator getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDeclarator( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.Builder subBuilder = null; + if (declaratorCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.Builder subBuilder = null; + if (declaratorCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 2; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.Builder subBuilder = null; + if (declaratorCase_ == 3) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 3; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.Builder subBuilder = null; + if (declaratorCase_ == 4) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 4; + break; + } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.Builder subBuilder = null; + if (declaratorCase_ == 5) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 5; + break; + } + case 50: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.Builder subBuilder = null; + if (declaratorCase_ == 6) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 6; + break; + } + case 58: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.Builder subBuilder = null; + if (declaratorCase_ == 7) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 7; + break; + } + case 66: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.Builder subBuilder = null; + if (declaratorCase_ == 8) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 8; + break; + } + case 74: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.Builder subBuilder = null; + if (declaratorCase_ == 9) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 9; + break; + } + case 82: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.Builder subBuilder = null; + if (declaratorCase_ == 10) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 10; + break; + } + case 90: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.Builder subBuilder = null; + if (declaratorCase_ == 11) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 11; + 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 IrDeclarator parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDeclarator(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + private int declaratorCase_ = 0; + private java.lang.Object declarator_; + public enum DeclaratorCase + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + IR_ANONYMOUS_INIT(1), + IR_CLASS(2), + IR_CONSTRUCTOR(3), + IR_ENUM_ENTRY(4), + IR_FIELD(5), + IR_FUNCTION(6), + IR_PROPERTY(7), + IR_TYPE_ALIAS(8), + IR_TYPE_PARAMETER(9), + IR_VARIABLE(10), + IR_VALUE_PARAMETER(11), + DECLARATOR_NOT_SET(0); + private int value = 0; + private DeclaratorCase(int value) { + this.value = value; + } + public static DeclaratorCase valueOf(int value) { + switch (value) { + case 1: return IR_ANONYMOUS_INIT; + case 2: return IR_CLASS; + case 3: return IR_CONSTRUCTOR; + case 4: return IR_ENUM_ENTRY; + case 5: return IR_FIELD; + case 6: return IR_FUNCTION; + case 7: return IR_PROPERTY; + case 8: return IR_TYPE_ALIAS; + case 9: return IR_TYPE_PARAMETER; + case 10: return IR_VARIABLE; + case 11: return IR_VALUE_PARAMETER; + case 0: return DECLARATOR_NOT_SET; + default: throw new java.lang.IllegalArgumentException( + "Value is undefined for this oneof enum."); + } + } + public int getNumber() { + return this.value; + } + }; + + public DeclaratorCase + getDeclaratorCase() { + return DeclaratorCase.valueOf( + declaratorCase_); + } + + public static final int IR_ANONYMOUS_INIT_FIELD_NUMBER = 1; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + public boolean hasIrAnonymousInit() { + return declaratorCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit getIrAnonymousInit() { + if (declaratorCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.getDefaultInstance(); + } + + public static final int IR_CLASS_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + public boolean hasIrClass() { + return declaratorCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass getIrClass() { + if (declaratorCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.getDefaultInstance(); + } + + public static final int IR_CONSTRUCTOR_FIELD_NUMBER = 3; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + public boolean hasIrConstructor() { + return declaratorCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor getIrConstructor() { + if (declaratorCase_ == 3) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.getDefaultInstance(); + } + + public static final int IR_ENUM_ENTRY_FIELD_NUMBER = 4; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + public boolean hasIrEnumEntry() { + return declaratorCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry getIrEnumEntry() { + if (declaratorCase_ == 4) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.getDefaultInstance(); + } + + public static final int IR_FIELD_FIELD_NUMBER = 5; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + public boolean hasIrField() { + return declaratorCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField getIrField() { + if (declaratorCase_ == 5) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance(); + } + + public static final int IR_FUNCTION_FIELD_NUMBER = 6; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + public boolean hasIrFunction() { + return declaratorCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getIrFunction() { + if (declaratorCase_ == 6) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + } + + public static final int IR_PROPERTY_FIELD_NUMBER = 7; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + public boolean hasIrProperty() { + return declaratorCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty getIrProperty() { + if (declaratorCase_ == 7) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.getDefaultInstance(); + } + + public static final int IR_TYPE_ALIAS_FIELD_NUMBER = 8; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + public boolean hasIrTypeAlias() { + return declaratorCase_ == 8; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias getIrTypeAlias() { + if (declaratorCase_ == 8) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.getDefaultInstance(); + } + + public static final int IR_TYPE_PARAMETER_FIELD_NUMBER = 9; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + public boolean hasIrTypeParameter() { + return declaratorCase_ == 9; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter getIrTypeParameter() { + if (declaratorCase_ == 9) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.getDefaultInstance(); + } + + public static final int IR_VARIABLE_FIELD_NUMBER = 10; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + public boolean hasIrVariable() { + return declaratorCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable getIrVariable() { + if (declaratorCase_ == 10) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.getDefaultInstance(); + } + + public static final int IR_VALUE_PARAMETER_FIELD_NUMBER = 11; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + public boolean hasIrValueParameter() { + return declaratorCase_ == 11; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter getIrValueParameter() { + if (declaratorCase_ == 11) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.getDefaultInstance(); + } + + private void initFields() { + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (hasIrAnonymousInit()) { + if (!getIrAnonymousInit().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasIrClass()) { + if (!getIrClass().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasIrConstructor()) { + if (!getIrConstructor().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasIrEnumEntry()) { + if (!getIrEnumEntry().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasIrField()) { + if (!getIrField().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasIrFunction()) { + if (!getIrFunction().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasIrProperty()) { + if (!getIrProperty().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasIrTypeParameter()) { + if (!getIrTypeParameter().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasIrVariable()) { + if (!getIrVariable().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasIrValueParameter()) { + if (!getIrValueParameter().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (declaratorCase_ == 1) { + output.writeMessage(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit) declarator_); + } + if (declaratorCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass) declarator_); + } + if (declaratorCase_ == 3) { + output.writeMessage(3, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor) declarator_); + } + if (declaratorCase_ == 4) { + output.writeMessage(4, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry) declarator_); + } + if (declaratorCase_ == 5) { + output.writeMessage(5, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField) declarator_); + } + if (declaratorCase_ == 6) { + output.writeMessage(6, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction) declarator_); + } + if (declaratorCase_ == 7) { + output.writeMessage(7, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty) declarator_); + } + if (declaratorCase_ == 8) { + output.writeMessage(8, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias) declarator_); + } + if (declaratorCase_ == 9) { + output.writeMessage(9, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter) declarator_); + } + if (declaratorCase_ == 10) { + output.writeMessage(10, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable) declarator_); + } + if (declaratorCase_ == 11) { + output.writeMessage(11, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter) declarator_); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (declaratorCase_ == 1) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit) declarator_); + } + if (declaratorCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass) declarator_); + } + if (declaratorCase_ == 3) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor) declarator_); + } + if (declaratorCase_ == 4) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry) declarator_); + } + if (declaratorCase_ == 5) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField) declarator_); + } + if (declaratorCase_ == 6) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(6, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction) declarator_); + } + if (declaratorCase_ == 7) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(7, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty) declarator_); + } + if (declaratorCase_ == 8) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(8, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias) declarator_); + } + if (declaratorCase_ == 9) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(9, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter) declarator_); + } + if (declaratorCase_ == 10) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(10, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable) declarator_); + } + if (declaratorCase_ == 11) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(11, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter) declarator_); + } + 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.KotlinIr.IrDeclarator 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.KotlinIr.IrDeclarator 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.KotlinIr.IrDeclarator parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator 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.KotlinIr.IrDeclarator parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator 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.KotlinIr.IrDeclarator parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator 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.KotlinIr.IrDeclarator parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator 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.KotlinIr.IrDeclarator prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDeclarator} + * + * 
+     * TODO: we need an extension mechanism to accomodate new
+     * IR operators in upcoming releases.
+     *
+ */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrDeclarator) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaratorOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + declaratorCase_ = 0; + declarator_ = null; + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (declaratorCase_ == 1) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 2) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 3) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 4) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 5) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 6) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 7) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 8) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 9) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 10) { + result.declarator_ = declarator_; + } + if (declaratorCase_ == 11) { + result.declarator_ = declarator_; + } + result.bitField0_ = to_bitField0_; + result.declaratorCase_ = declaratorCase_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.getDefaultInstance()) return this; + switch (other.getDeclaratorCase()) { + case IR_ANONYMOUS_INIT: { + mergeIrAnonymousInit(other.getIrAnonymousInit()); + break; + } + case IR_CLASS: { + mergeIrClass(other.getIrClass()); + break; + } + case IR_CONSTRUCTOR: { + mergeIrConstructor(other.getIrConstructor()); + break; + } + case IR_ENUM_ENTRY: { + mergeIrEnumEntry(other.getIrEnumEntry()); + break; + } + case IR_FIELD: { + mergeIrField(other.getIrField()); + break; + } + case IR_FUNCTION: { + mergeIrFunction(other.getIrFunction()); + break; + } + case IR_PROPERTY: { + mergeIrProperty(other.getIrProperty()); + break; + } + case IR_TYPE_ALIAS: { + mergeIrTypeAlias(other.getIrTypeAlias()); + break; + } + case IR_TYPE_PARAMETER: { + mergeIrTypeParameter(other.getIrTypeParameter()); + break; + } + case IR_VARIABLE: { + mergeIrVariable(other.getIrVariable()); + break; + } + case IR_VALUE_PARAMETER: { + mergeIrValueParameter(other.getIrValueParameter()); + break; + } + case DECLARATOR_NOT_SET: { + break; + } + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (hasIrAnonymousInit()) { + if (!getIrAnonymousInit().isInitialized()) { + + return false; + } + } + if (hasIrClass()) { + if (!getIrClass().isInitialized()) { + + return false; + } + } + if (hasIrConstructor()) { + if (!getIrConstructor().isInitialized()) { + + return false; + } + } + if (hasIrEnumEntry()) { + if (!getIrEnumEntry().isInitialized()) { + + return false; + } + } + if (hasIrField()) { + if (!getIrField().isInitialized()) { + + return false; + } + } + if (hasIrFunction()) { + if (!getIrFunction().isInitialized()) { + + return false; + } + } + if (hasIrProperty()) { + if (!getIrProperty().isInitialized()) { + + return false; + } + } + if (hasIrTypeParameter()) { + if (!getIrTypeParameter().isInitialized()) { + + return false; + } + } + if (hasIrVariable()) { + if (!getIrVariable().isInitialized()) { + + return false; + } + } + if (hasIrValueParameter()) { + if (!getIrValueParameter().isInitialized()) { + + 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.KotlinIr.IrDeclarator parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int declaratorCase_ = 0; + private java.lang.Object declarator_; + public DeclaratorCase + getDeclaratorCase() { + return DeclaratorCase.valueOf( + declaratorCase_); + } + + public Builder clearDeclarator() { + declaratorCase_ = 0; + declarator_ = null; + return this; + } + + private int bitField0_; + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + public boolean hasIrAnonymousInit() { + return declaratorCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit getIrAnonymousInit() { + if (declaratorCase_ == 1) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + public Builder setIrAnonymousInit(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + public Builder setIrAnonymousInit( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + public Builder mergeIrAnonymousInit(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit value) { + if (declaratorCase_ == 1 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrAnonymousInit) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrAnonymousInit ir_anonymous_init = 1; + */ + public Builder clearIrAnonymousInit() { + if (declaratorCase_ == 1) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + public boolean hasIrClass() { + return declaratorCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass getIrClass() { + if (declaratorCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + public Builder setIrClass(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + public Builder setIrClass( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + public Builder mergeIrClass(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass value) { + if (declaratorCase_ == 2 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrClass) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrClass ir_class = 2; + */ + public Builder clearIrClass() { + if (declaratorCase_ == 2) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + public boolean hasIrConstructor() { + return declaratorCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor getIrConstructor() { + if (declaratorCase_ == 3) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + public Builder setIrConstructor(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + public Builder setIrConstructor( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + public Builder mergeIrConstructor(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor value) { + if (declaratorCase_ == 3 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrConstructor) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrConstructor ir_constructor = 3; + */ + public Builder clearIrConstructor() { + if (declaratorCase_ == 3) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + public boolean hasIrEnumEntry() { + return declaratorCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry getIrEnumEntry() { + if (declaratorCase_ == 4) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + public Builder setIrEnumEntry(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + public Builder setIrEnumEntry( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + public Builder mergeIrEnumEntry(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry value) { + if (declaratorCase_ == 4 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrEnumEntry) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrEnumEntry ir_enum_entry = 4; + */ + public Builder clearIrEnumEntry() { + if (declaratorCase_ == 4) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + public boolean hasIrField() { + return declaratorCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField getIrField() { + if (declaratorCase_ == 5) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + public Builder setIrField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + public Builder setIrField( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + public Builder mergeIrField(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField value) { + if (declaratorCase_ == 5 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrField) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrField ir_field = 5; + */ + public Builder clearIrField() { + if (declaratorCase_ == 5) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + public boolean hasIrFunction() { + return declaratorCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction getIrFunction() { + if (declaratorCase_ == 6) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + public Builder setIrFunction(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + public Builder setIrFunction( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + public Builder mergeIrFunction(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction value) { + if (declaratorCase_ == 6 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrFunction) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrFunction ir_function = 6; + */ + public Builder clearIrFunction() { + if (declaratorCase_ == 6) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + public boolean hasIrProperty() { + return declaratorCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty getIrProperty() { + if (declaratorCase_ == 7) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + public Builder setIrProperty(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + public Builder setIrProperty( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + public Builder mergeIrProperty(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty value) { + if (declaratorCase_ == 7 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrProperty) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrProperty ir_property = 7; + */ + public Builder clearIrProperty() { + if (declaratorCase_ == 7) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + public boolean hasIrTypeAlias() { + return declaratorCase_ == 8; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias getIrTypeAlias() { + if (declaratorCase_ == 8) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + public Builder setIrTypeAlias(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + public Builder setIrTypeAlias( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + public Builder mergeIrTypeAlias(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias value) { + if (declaratorCase_ == 8 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeAlias) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeAlias ir_type_alias = 8; + */ + public Builder clearIrTypeAlias() { + if (declaratorCase_ == 8) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + public boolean hasIrTypeParameter() { + return declaratorCase_ == 9; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter getIrTypeParameter() { + if (declaratorCase_ == 9) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + public Builder setIrTypeParameter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + public Builder setIrTypeParameter( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + public Builder mergeIrTypeParameter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter value) { + if (declaratorCase_ == 9 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrTypeParameter) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrTypeParameter ir_type_parameter = 9; + */ + public Builder clearIrTypeParameter() { + if (declaratorCase_ == 9) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + public boolean hasIrVariable() { + return declaratorCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable getIrVariable() { + if (declaratorCase_ == 10) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + public Builder setIrVariable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + public Builder setIrVariable( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + public Builder mergeIrVariable(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable value) { + if (declaratorCase_ == 10 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrVariable) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrVariable ir_variable = 10; + */ + public Builder clearIrVariable() { + if (declaratorCase_ == 10) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + public boolean hasIrValueParameter() { + return declaratorCase_ == 11; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter getIrValueParameter() { + if (declaratorCase_ == 11) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter) declarator_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + public Builder setIrValueParameter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + public Builder setIrValueParameter( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + public Builder mergeIrValueParameter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter value) { + if (declaratorCase_ == 11 && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrValueParameter) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrValueParameter ir_value_parameter = 11; + */ + public Builder clearIrValueParameter() { + if (declaratorCase_ == 11) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrDeclarator) + } + + static { + defaultInstance = new IrDeclarator(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrDeclarator) + } + + public interface IrDeclarationOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrDeclaration) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin getOrigin(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + boolean hasCoordinates(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + boolean hasAnnotations(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + boolean hasDeclarator(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator getDeclarator(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDeclaration} + */ + public static final class IrDeclaration extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrDeclaration) + IrDeclarationOrBuilder { + // Use IrDeclaration.newBuilder() to construct. + private IrDeclaration(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDeclaration(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDeclaration defaultInstance; + public static IrDeclaration getDefaultInstance() { + return defaultInstance; + } + + public IrDeclaration getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDeclaration( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = coordinates_.toBuilder(); + } + coordinates_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(coordinates_); + coordinates_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = annotations_.toBuilder(); + } + annotations_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(annotations_); + annotations_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = declarator_.toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(declarator_); + declarator_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + 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 IrDeclaration parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDeclaration(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int ORIGIN_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin origin_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin getOrigin() { + return origin_; + } + + public static final int COORDINATES_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates coordinates_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates() { + return coordinates_; + } + + public static final int ANNOTATIONS_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + + public static final int DECLARATOR_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator declarator_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + public boolean hasDeclarator() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator getDeclarator() { + return declarator_; + } + + private void initFields() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.getDefaultInstance(); + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasCoordinates()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasAnnotations()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasDeclarator()) { + memoizedIsInitialized = 0; + return false; + } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCoordinates().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getAnnotations().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getDeclarator().isInitialized()) { + 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.writeMessage(1, origin_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, coordinates_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, annotations_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, declarator_); + } + 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 + .computeMessageSize(1, origin_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, coordinates_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, annotations_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, declarator_); + } + 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.KotlinIr.IrDeclaration 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.KotlinIr.IrDeclaration 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.KotlinIr.IrDeclaration parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration 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.KotlinIr.IrDeclaration parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration 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.KotlinIr.IrDeclaration parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration 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.KotlinIr.IrDeclaration parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration 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.KotlinIr.IrDeclaration prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrDeclaration} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrDeclaration) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.origin_ = origin_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.coordinates_ = coordinates_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.annotations_ = annotations_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.declarator_ = declarator_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance()) return this; + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } + if (other.hasCoordinates()) { + mergeCoordinates(other.getCoordinates()); + } + if (other.hasAnnotations()) { + mergeAnnotations(other.getAnnotations()); + } + if (other.hasDeclarator()) { + mergeDeclarator(other.getDeclarator()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasOrigin()) { + + return false; + } + if (!hasCoordinates()) { + + return false; + } + if (!hasAnnotations()) { + + return false; + } + if (!hasDeclarator()) { + + return false; + } + if (!getOrigin().isInitialized()) { + + return false; + } + if (!getCoordinates().isInitialized()) { + + return false; + } + if (!getAnnotations().isInitialized()) { + + return false; + } + if (!getDeclarator().isInitialized()) { + + 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.KotlinIr.IrDeclaration parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarationOrigin origin = 1; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarationOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates() { + return coordinates_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public Builder setCoordinates(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates value) { + if (value == null) { + throw new NullPointerException(); + } + coordinates_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public Builder setCoordinates( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.Builder builderForValue) { + coordinates_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public Builder mergeCoordinates(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + coordinates_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance()) { + coordinates_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.newBuilder(coordinates_).mergeFrom(value).buildPartial(); + } else { + coordinates_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 2; + */ + public Builder clearCoordinates() { + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations getAnnotations() { + return annotations_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + public Builder setAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (value == null) { + throw new NullPointerException(); + } + annotations_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + public Builder setAnnotations( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.Builder builderForValue) { + annotations_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + public Builder mergeAnnotations(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + annotations_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance()) { + annotations_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.newBuilder(annotations_).mergeFrom(value).buildPartial(); + } else { + annotations_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Annotations annotations = 3; + */ + public Builder clearAnnotations() { + annotations_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Annotations.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + public boolean hasDeclarator() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator getDeclarator() { + return declarator_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + public Builder setDeclarator(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + public Builder setDeclarator( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.Builder builderForValue) { + declarator_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + public Builder mergeDeclarator(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + declarator_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.getDefaultInstance()) { + declarator_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.newBuilder(declarator_).mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclarator declarator = 4; + */ + public Builder clearDeclarator() { + declarator_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclarator.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrDeclaration) + } + + static { + defaultInstance = new IrDeclaration(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrDeclaration) + } + + public interface IrBranchOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrBranch) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + boolean hasCondition(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getCondition(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + boolean hasResult(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getResult(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrBranch} + */ + public static final class IrBranch extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrBranch) + IrBranchOrBuilder { + // Use IrBranch.newBuilder() to construct. + private IrBranch(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrBranch(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrBranch defaultInstance; + public static IrBranch getDefaultInstance() { + return defaultInstance; + } + + public IrBranch getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrBranch( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = condition_.toBuilder(); + } + condition_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(condition_); + condition_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = result_.toBuilder(); + } + result_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(result_); + result_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrBranch parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrBranch(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int CONDITION_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression condition_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + public boolean hasCondition() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getCondition() { + return condition_; + } + + public static final int RESULT_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression result_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getResult() { + return result_; + } + + private void initFields() { + condition_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCondition()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasResult()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCondition().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getResult().isInitialized()) { + 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.writeMessage(1, condition_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, result_); + } + 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 + .computeMessageSize(1, condition_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, result_); + } + 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.KotlinIr.IrBranch 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.KotlinIr.IrBranch 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.KotlinIr.IrBranch parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch 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.KotlinIr.IrBranch parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch 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.KotlinIr.IrBranch parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch 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.KotlinIr.IrBranch parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch 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.KotlinIr.IrBranch prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrBranch} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrBranch) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranchOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + condition_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.condition_ = condition_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.result_ = result_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.getDefaultInstance()) return this; + if (other.hasCondition()) { + mergeCondition(other.getCondition()); + } + if (other.hasResult()) { + mergeResult(other.getResult()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasCondition()) { + + return false; + } + if (!hasResult()) { + + return false; + } + if (!getCondition().isInitialized()) { + + return false; + } + if (!getResult().isInitialized()) { + + 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.KotlinIr.IrBranch parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression condition_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + public boolean hasCondition() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getCondition() { + return condition_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + public Builder setCondition(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + condition_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + public Builder setCondition( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + condition_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + public Builder mergeCondition(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + condition_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + condition_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(condition_).mergeFrom(value).buildPartial(); + } else { + condition_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression condition = 1; + */ + public Builder clearCondition() { + condition_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getResult() { + return result_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public Builder setResult(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + result_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public Builder setResult( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + result_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public Builder mergeResult(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + result_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + result_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(result_).mergeFrom(value).buildPartial(); + } else { + result_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public Builder clearResult() { + result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrBranch) + } + + static { + defaultInstance = new IrBranch(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrBranch) + } + + public interface IrBlockBodyOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrBlockBody) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + java.util.List + getStatementList(); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getStatement(int index); + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + int getStatementCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrBlockBody} + */ + public static final class IrBlockBody extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrBlockBody) + IrBlockBodyOrBuilder { + // Use IrBlockBody.newBuilder() to construct. + private IrBlockBody(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrBlockBody(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrBlockBody defaultInstance; + public static IrBlockBody getDefaultInstance() { + return defaultInstance; + } + + public IrBlockBody getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrBlockBody( + 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); + 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 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + statement_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.PARSER, extensionRegistry)); + 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 { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = java.util.Collections.unmodifiableList(statement_); + } + 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 IrBlockBody parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrBlockBody(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + public static final int STATEMENT_FIELD_NUMBER = 1; + private java.util.List statement_; + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public java.util.List getStatementList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public java.util.List + getStatementOrBuilderList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrBuilder getStatementOrBuilder( + int index) { + return statement_.get(index); + } + + private void initFields() { + statement_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getStatementCount(); i++) { + if (!getStatement(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + for (int i = 0; i < statement_.size(); i++) { + output.writeMessage(1, statement_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < statement_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, statement_.get(i)); + } + 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.KotlinIr.IrBlockBody 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.KotlinIr.IrBlockBody 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.KotlinIr.IrBlockBody parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody 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.KotlinIr.IrBlockBody parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody 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.KotlinIr.IrBlockBody parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody 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.KotlinIr.IrBlockBody parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody 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.KotlinIr.IrBlockBody prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrBlockBody} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrBlockBody) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBodyOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + statement_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = java.util.Collections.unmodifiableList(statement_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.statement_ = statement_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.getDefaultInstance()) return this; + if (!other.statement_.isEmpty()) { + if (statement_.isEmpty()) { + statement_ = other.statement_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureStatementIsMutable(); + statement_.addAll(other.statement_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + for (int i = 0; i < getStatementCount(); i++) { + if (!getStatement(i).isInitialized()) { + + 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.KotlinIr.IrBlockBody parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List statement_ = + java.util.Collections.emptyList(); + private void ensureStatementIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = new java.util.ArrayList(statement_); + bitField0_ |= 0x00000001; + } + } + + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public java.util.List getStatementList() { + return java.util.Collections.unmodifiableList(statement_); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addStatement(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addStatement( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder addAllStatement( + java.lang.Iterable values) { + ensureStatementIsMutable(); + org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll( + values, statement_); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder clearStatement() { + statement_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; + */ + public Builder removeStatement(int index) { + ensureStatementIsMutable(); + statement_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrBlockBody) + } + + static { + defaultInstance = new IrBlockBody(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrBlockBody) + } + + public interface IrCatchOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrCatch) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + boolean hasCatchParameter(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getCatchParameter(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + boolean hasResult(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getResult(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrCatch} + */ + public static final class IrCatch extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrCatch) + IrCatchOrBuilder { + // Use IrCatch.newBuilder() to construct. + private IrCatch(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrCatch(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrCatch defaultInstance; + public static IrCatch getDefaultInstance() { + return defaultInstance; + } + + public IrCatch getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrCatch( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = catchParameter_.toBuilder(); + } + catchParameter_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(catchParameter_); + catchParameter_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = result_.toBuilder(); + } + result_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(result_); + result_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + 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 IrCatch parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrCatch(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int CATCH_PARAMETER_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration catchParameter_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + public boolean hasCatchParameter() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getCatchParameter() { + return catchParameter_; + } + + public static final int RESULT_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression result_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getResult() { + return result_; + } + + private void initFields() { + catchParameter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCatchParameter()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasResult()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCatchParameter().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getResult().isInitialized()) { + 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.writeMessage(1, catchParameter_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, result_); + } + 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 + .computeMessageSize(1, catchParameter_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, result_); + } + 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.KotlinIr.IrCatch 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.KotlinIr.IrCatch 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.KotlinIr.IrCatch parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch 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.KotlinIr.IrCatch parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch 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.KotlinIr.IrCatch parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch 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.KotlinIr.IrCatch parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch 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.KotlinIr.IrCatch prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrCatch} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrCatch) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatchOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + catchParameter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.catchParameter_ = catchParameter_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.result_ = result_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.getDefaultInstance()) return this; + if (other.hasCatchParameter()) { + mergeCatchParameter(other.getCatchParameter()); + } + if (other.hasResult()) { + mergeResult(other.getResult()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasCatchParameter()) { + + return false; + } + if (!hasResult()) { + + return false; + } + if (!getCatchParameter().isInitialized()) { + + return false; + } + if (!getResult().isInitialized()) { + + 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.KotlinIr.IrCatch parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration catchParameter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + public boolean hasCatchParameter() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getCatchParameter() { + return catchParameter_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + public Builder setCatchParameter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + catchParameter_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + public Builder setCatchParameter( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + catchParameter_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + public Builder mergeCatchParameter(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + catchParameter_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance()) { + catchParameter_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.newBuilder(catchParameter_).mergeFrom(value).buildPartial(); + } else { + catchParameter_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration catch_parameter = 1; + */ + public Builder clearCatchParameter() { + catchParameter_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getResult() { + return result_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public Builder setResult(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + result_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public Builder setResult( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + result_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public Builder mergeResult(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + result_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + result_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder(result_).mergeFrom(value).buildPartial(); + } else { + result_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression result = 2; + */ + public Builder clearResult() { + result_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrCatch) + } + + static { + defaultInstance = new IrCatch(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrCatch) + } + + public interface IrSyntheticBodyOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind kind = 1; + */ + boolean hasKind(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind kind = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind getKind(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody} + */ + public static final class IrSyntheticBody extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody) + IrSyntheticBodyOrBuilder { + // Use IrSyntheticBody.newBuilder() to construct. + private IrSyntheticBody(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrSyntheticBody(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrSyntheticBody defaultInstance; + public static IrSyntheticBody getDefaultInstance() { + return defaultInstance; + } + + public IrSyntheticBody getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrSyntheticBody( + 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); + 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: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind value = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + kind_ = value; + } + 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 IrSyntheticBody parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrSyntheticBody(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int KIND_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind kind_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind kind = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind getKind() { + return kind_; + } + + private void initFields() { + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind.ENUM_VALUES; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasKind()) { + 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.writeEnum(1, kind_.getNumber()); + } + 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 + .computeEnumSize(1, kind_.getNumber()); + } + 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.KotlinIr.IrSyntheticBody 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.KotlinIr.IrSyntheticBody 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.KotlinIr.IrSyntheticBody parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody 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.KotlinIr.IrSyntheticBody parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody 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.KotlinIr.IrSyntheticBody parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody 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.KotlinIr.IrSyntheticBody parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody 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.KotlinIr.IrSyntheticBody prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind.ENUM_VALUES; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.kind_ = kind_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.getDefaultInstance()) return this; + if (other.hasKind()) { + setKind(other.getKind()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasKind()) { + + 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.KotlinIr.IrSyntheticBody parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind.ENUM_VALUES; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind kind = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind getKind() { + return kind_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind kind = 1; + */ + public Builder setKind(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + kind_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBodyKind kind = 1; + */ + public Builder clearKind() { + bitField0_ = (bitField0_ & ~0x00000001); + kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBodyKind.ENUM_VALUES; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody) + } + + static { + defaultInstance = new IrSyntheticBody(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody) + } + + public interface IrStatementOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.IrStatement) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + boolean hasCoordinates(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + boolean hasDeclaration(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDeclaration(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + boolean hasExpression(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + boolean hasBlockBody(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody getBlockBody(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + boolean hasBranch(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch getBranch(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + boolean hasCatch(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch getCatch(); + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + boolean hasSyntheticBody(); + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody getSyntheticBody(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrStatement} + * + * 
+   * Let's try to map IrElement as well as IrStatement to IrStatement.
+   *
+ */ + public static final class IrStatement extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.IrStatement) + IrStatementOrBuilder { + // Use IrStatement.newBuilder() to construct. + private IrStatement(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrStatement(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrStatement defaultInstance; + public static IrStatement getDefaultInstance() { + return defaultInstance; + } + + public IrStatement getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrStatement( + 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); + 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 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = coordinates_.toBuilder(); + } + coordinates_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(coordinates_); + coordinates_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder subBuilder = null; + if (statementCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 2; + break; + } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder subBuilder = null; + if (statementCase_ == 3) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 3; + break; + } + case 34: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.Builder subBuilder = null; + if (statementCase_ == 4) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 4; + break; + } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.Builder subBuilder = null; + if (statementCase_ == 5) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 5; + break; + } + case 50: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.Builder subBuilder = null; + if (statementCase_ == 6) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 6; + break; + } + case 58: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.Builder subBuilder = null; + if (statementCase_ == 7) { + subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 7; + 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 IrStatement parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrStatement(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + private int statementCase_ = 0; + private java.lang.Object statement_; + public enum StatementCase + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + DECLARATION(2), + EXPRESSION(3), + BLOCK_BODY(4), + BRANCH(5), + CATCH(6), + SYNTHETIC_BODY(7), + STATEMENT_NOT_SET(0); + private int value = 0; + private StatementCase(int value) { + this.value = value; + } + public static StatementCase valueOf(int value) { + switch (value) { + case 2: return DECLARATION; + case 3: return EXPRESSION; + case 4: return BLOCK_BODY; + case 5: return BRANCH; + case 6: return CATCH; + case 7: return SYNTHETIC_BODY; + case 0: return STATEMENT_NOT_SET; + default: throw new java.lang.IllegalArgumentException( + "Value is undefined for this oneof enum."); + } + } + public int getNumber() { + return this.value; + } + }; + + public StatementCase + getStatementCase() { + return StatementCase.valueOf( + statementCase_); + } + + public static final int COORDINATES_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates coordinates_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates() { + return coordinates_; + } + + public static final int DECLARATION_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + public boolean hasDeclaration() { + return statementCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDeclaration() { + if (statementCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + } + + public static final int EXPRESSION_FIELD_NUMBER = 3; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + public boolean hasExpression() { + return statementCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression() { + if (statementCase_ == 3) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + + public static final int BLOCK_BODY_FIELD_NUMBER = 4; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + public boolean hasBlockBody() { + return statementCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody getBlockBody() { + if (statementCase_ == 4) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.getDefaultInstance(); + } + + public static final int BRANCH_FIELD_NUMBER = 5; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + public boolean hasBranch() { + return statementCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch getBranch() { + if (statementCase_ == 5) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.getDefaultInstance(); + } + + public static final int CATCH_FIELD_NUMBER = 6; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + public boolean hasCatch() { + return statementCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch getCatch() { + if (statementCase_ == 6) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.getDefaultInstance(); + } + + public static final int SYNTHETIC_BODY_FIELD_NUMBER = 7; + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + public boolean hasSyntheticBody() { + return statementCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody getSyntheticBody() { + if (statementCase_ == 7) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.getDefaultInstance(); + } + + private void initFields() { + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCoordinates()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCoordinates().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasDeclaration()) { + if (!getDeclaration().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasExpression()) { + if (!getExpression().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasBlockBody()) { + if (!getBlockBody().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasBranch()) { + if (!getBranch().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasCatch()) { + if (!getCatch().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasSyntheticBody()) { + if (!getSyntheticBody().isInitialized()) { + 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.writeMessage(1, coordinates_); + } + if (statementCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration) statement_); + } + if (statementCase_ == 3) { + output.writeMessage(3, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) statement_); + } + if (statementCase_ == 4) { + output.writeMessage(4, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody) statement_); + } + if (statementCase_ == 5) { + output.writeMessage(5, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch) statement_); + } + if (statementCase_ == 6) { + output.writeMessage(6, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch) statement_); + } + if (statementCase_ == 7) { + output.writeMessage(7, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody) statement_); + } + 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 + .computeMessageSize(1, coordinates_); + } + if (statementCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration) statement_); + } + if (statementCase_ == 3) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) statement_); + } + if (statementCase_ == 4) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody) statement_); + } + if (statementCase_ == 5) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch) statement_); + } + if (statementCase_ == 6) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(6, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch) statement_); + } + if (statementCase_ == 7) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(7, (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody) statement_); + } + 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.KotlinIr.IrStatement 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.KotlinIr.IrStatement 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.KotlinIr.IrStatement parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement 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.KotlinIr.IrStatement parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement 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.KotlinIr.IrStatement parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement 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.KotlinIr.IrStatement parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement 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.KotlinIr.IrStatement prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrStatement} + * + * 
+     * Let's try to map IrElement as well as IrStatement to IrStatement.
+     *
+ */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.IrStatement) + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrBuilder { + // Construct using org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + statementCase_ = 0; + statement_ = null; + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement getDefaultInstanceForType() { + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance(); + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement build() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement buildPartial() { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.coordinates_ = coordinates_; + if (statementCase_ == 2) { + result.statement_ = statement_; + } + if (statementCase_ == 3) { + result.statement_ = statement_; + } + if (statementCase_ == 4) { + result.statement_ = statement_; + } + if (statementCase_ == 5) { + result.statement_ = statement_; + } + if (statementCase_ == 6) { + result.statement_ = statement_; + } + if (statementCase_ == 7) { + result.statement_ = statement_; + } + result.bitField0_ = to_bitField0_; + result.statementCase_ = statementCase_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement other) { + if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.getDefaultInstance()) return this; + if (other.hasCoordinates()) { + mergeCoordinates(other.getCoordinates()); + } + switch (other.getStatementCase()) { + case DECLARATION: { + mergeDeclaration(other.getDeclaration()); + break; + } + case EXPRESSION: { + mergeExpression(other.getExpression()); + break; + } + case BLOCK_BODY: { + mergeBlockBody(other.getBlockBody()); + break; + } + case BRANCH: { + mergeBranch(other.getBranch()); + break; + } + case CATCH: { + mergeCatch(other.getCatch()); + break; + } + case SYNTHETIC_BODY: { + mergeSyntheticBody(other.getSyntheticBody()); + break; + } + case STATEMENT_NOT_SET: { + break; + } + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasCoordinates()) { + + return false; + } + if (!getCoordinates().isInitialized()) { + + return false; + } + if (hasDeclaration()) { + if (!getDeclaration().isInitialized()) { + + return false; + } + } + if (hasExpression()) { + if (!getExpression().isInitialized()) { + + return false; + } + } + if (hasBlockBody()) { + if (!getBlockBody().isInitialized()) { + + return false; + } + } + if (hasBranch()) { + if (!getBranch().isInitialized()) { + + return false; + } + } + if (hasCatch()) { + if (!getCatch().isInitialized()) { + + return false; + } + } + if (hasSyntheticBody()) { + if (!getSyntheticBody().isInitialized()) { + + 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.KotlinIr.IrStatement parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int statementCase_ = 0; + private java.lang.Object statement_; + public StatementCase + getStatementCase() { + return StatementCase.valueOf( + statementCase_); + } + + public Builder clearStatement() { + statementCase_ = 0; + statement_ = null; + return this; + } + + private int bitField0_; + + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates getCoordinates() { + return coordinates_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + public Builder setCoordinates(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates value) { + if (value == null) { + throw new NullPointerException(); + } + coordinates_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + public Builder setCoordinates( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.Builder builderForValue) { + coordinates_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + public Builder mergeCoordinates(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + coordinates_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance()) { + coordinates_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.newBuilder(coordinates_).mergeFrom(value).buildPartial(); + } else { + coordinates_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.Coordinates coordinates = 1; + */ + public Builder clearCoordinates() { + coordinates_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.Coordinates.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + public boolean hasDeclaration() { + return statementCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration getDeclaration() { + if (statementCase_ == 2) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + public Builder setDeclaration(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + public Builder setDeclaration( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + public Builder mergeDeclaration(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration value) { + if (statementCase_ == 2 && + statement_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrDeclaration) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrDeclaration declaration = 2; + */ + public Builder clearDeclaration() { + if (statementCase_ == 2) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + public boolean hasExpression() { + return statementCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getExpression() { + if (statementCase_ == 3) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + public Builder setExpression(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + public Builder setExpression( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + public Builder mergeExpression(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression value) { + if (statementCase_ == 3 && + statement_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression expression = 3; + */ + public Builder clearExpression() { + if (statementCase_ == 3) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + public boolean hasBlockBody() { + return statementCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody getBlockBody() { + if (statementCase_ == 4) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + public Builder setBlockBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + public Builder setBlockBody( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + public Builder mergeBlockBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody value) { + if (statementCase_ == 4 && + statement_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlockBody) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBlockBody block_body = 4; + */ + public Builder clearBlockBody() { + if (statementCase_ == 4) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + public boolean hasBranch() { + return statementCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch getBranch() { + if (statementCase_ == 5) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + public Builder setBranch(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + public Builder setBranch( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + public Builder mergeBranch(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch value) { + if (statementCase_ == 5 && + statement_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBranch) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrBranch branch = 5; + */ + public Builder clearBranch() { + if (statementCase_ == 5) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + public boolean hasCatch() { + return statementCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch getCatch() { + if (statementCase_ == 6) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + public Builder setCatch(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + public Builder setCatch( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + public Builder mergeCatch(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch value) { + if (statementCase_ == 6 && + statement_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCatch) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrCatch catch = 6; + */ + public Builder clearCatch() { + if (statementCase_ == 6) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + public boolean hasSyntheticBody() { + return statementCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody getSyntheticBody() { + if (statementCase_ == 7) { + return (org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody) statement_; + } + return org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + public Builder setSyntheticBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + public Builder setSyntheticBody( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + public Builder mergeSyntheticBody(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody value) { + if (statementCase_ == 7 && + statement_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody.newBuilder((org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSyntheticBody) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.backend.common.serialization.IrSyntheticBody synthetic_body = 7; + */ + public Builder clearSyntheticBody() { + if (statementCase_ == 7) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrStatement) + } + + static { + defaultInstance = new IrStatement(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.IrStatement) + } + + + static { + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBufModuleDeserializer.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIrLinker.kt similarity index 73% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBufModuleDeserializer.kt rename to compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIrLinker.kt index ee3315fd76c..9c320393abd 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBufModuleDeserializer.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIrLinker.kt @@ -3,153 +3,132 @@ * that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +package org.jetbrains.kotlin.backend.common.serialization import org.jetbrains.kotlin.backend.common.LoggingContext import org.jetbrains.kotlin.backend.common.descriptors.* import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.impl.EmptyPackageFragmentDescriptor import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.metadata.JsKlibMetadataSerializerProtocol import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.* import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns +import org.jetbrains.kotlin.ir.expressions.impl.IrLoopBase import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.symbols.impl.* import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.util.SymbolTable import org.jetbrains.kotlin.ir.util.patchDeclarationParents import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite.* import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor import java.io.File -class IrKlibProtoBufModuleDeserializer( +abstract class KotlinIrLinker( currentModule: ModuleDescriptor, logger: LoggingContext, builtIns: IrBuiltIns, symbolTable: SymbolTable, private val forwardModuleDescriptor: ModuleDescriptor?) - : IrModuleDeserializer(logger, builtIns, symbolTable) { + : IrModuleDeserializer(logger, builtIns, symbolTable), + DescriptorUniqIdAware { - private val deserializedSymbols = mutableMapOf() - val knownBuiltInsDescriptors = mutableMapOf() + protected val deserializedSymbols = mutableMapOf() private val reachableTopLevels = mutableSetOf() private val deserializedTopLevels = mutableSetOf() private val forwardDeclarations = mutableSetOf() private var deserializedModuleDescriptor: ModuleDescriptor? = null - private var deserializedModuleProtoSymbolTables = mutableMapOf() - private var deserializedModuleProtoStringTables = mutableMapOf() - private var deserializedModuleProtoTypeTables = mutableMapOf() + private var deserializedModuleProtoSymbolTables = mutableMapOf() + private var deserializedModuleProtoStringTables = mutableMapOf() + private var deserializedModuleProtoTypeTables = mutableMapOf() + private var deserializedModuleLoops = mutableMapOf, IrLoopBase>() val resolvedForwardDeclarations = mutableMapOf() - private val descriptorReferenceDeserializer = object : DescriptorReferenceDeserializer(currentModule, resolvedForwardDeclarations) { - override fun resolveSpecialDescriptor(fqn: FqName) = builtIns.builtIns.getBuiltInClassByFqName(fqn) - - override fun checkIfSpecialDescriptorId(id: Long) = - (FUNCTION_INDEX_START + BUILT_IN_UNIQ_ID_CLASS_OFFSET) <= id && id < (FUNCTION_INDEX_START + BUILT_IN_UNIQ_ID_GAP) - - override fun getDescriptorIdOrNull(descriptor: DeclarationDescriptor) = - knownBuiltInsDescriptors[descriptor]?.index ?: if (isBuiltInFunction(descriptor)) - FUNCTION_INDEX_START + builtInFunctionId(descriptor) - else null - - } + abstract protected val descriptorReferenceDeserializer: DescriptorReferenceDeserializer private val descriptorToDirectoryMap = mutableMapOf() private fun irDirectory(m: ModuleDescriptor): File = descriptorToDirectoryMap[m]!! - private val FUNCTION_INDEX_START: Long - - init { - // TODO: think about order - var currentIndex = 0x1_0000_0000L - builtIns.knownBuiltins.forEach { - require(it is IrFunction) - deserializedSymbols.put(UniqIdKey(null, UniqId(currentIndex, isLocal = false)), it.symbol) - assert(symbolTable.referenceSimpleFunction(it.descriptor) == it.symbol) - currentIndex++ - } - - FUNCTION_INDEX_START = currentIndex - } - - private fun referenceDeserializedSymbol(proto: IrKlibProtoBuf.IrSymbolData, descriptor: DeclarationDescriptor?): IrSymbol = when (proto.kind) { - IrKlibProtoBuf.IrSymbolKind.ANONYMOUS_INIT_SYMBOL -> + private fun referenceDeserializedSymbol(proto: KotlinIr.IrSymbolData, descriptor: DeclarationDescriptor?): IrSymbol = when (proto.kind) { + KotlinIr.IrSymbolKind.ANONYMOUS_INIT_SYMBOL -> IrAnonymousInitializerSymbolImpl( descriptor as ClassDescriptor? ?: WrappedClassDescriptor() ) - IrKlibProtoBuf.IrSymbolKind.CLASS_SYMBOL -> + KotlinIr.IrSymbolKind.CLASS_SYMBOL -> symbolTable.referenceClass( descriptor as ClassDescriptor? ?: WrappedClassDescriptor() ) - IrKlibProtoBuf.IrSymbolKind.CONSTRUCTOR_SYMBOL -> + KotlinIr.IrSymbolKind.CONSTRUCTOR_SYMBOL -> symbolTable.referenceConstructor( descriptor as ClassConstructorDescriptor? ?: WrappedClassConstructorDescriptor() ) - IrKlibProtoBuf.IrSymbolKind.TYPE_PARAMETER_SYMBOL -> + KotlinIr.IrSymbolKind.TYPE_PARAMETER_SYMBOL -> symbolTable.referenceTypeParameter( descriptor as TypeParameterDescriptor? ?: WrappedTypeParameterDescriptor() ) - IrKlibProtoBuf.IrSymbolKind.ENUM_ENTRY_SYMBOL -> + KotlinIr.IrSymbolKind.ENUM_ENTRY_SYMBOL -> symbolTable.referenceEnumEntry( descriptor as ClassDescriptor? ?: WrappedEnumEntryDescriptor() ) - IrKlibProtoBuf.IrSymbolKind.STANDALONE_FIELD_SYMBOL -> + KotlinIr.IrSymbolKind.STANDALONE_FIELD_SYMBOL -> symbolTable.referenceField(WrappedFieldDescriptor()) - IrKlibProtoBuf.IrSymbolKind.FIELD_SYMBOL -> + KotlinIr.IrSymbolKind.FIELD_SYMBOL -> symbolTable.referenceField( descriptor as PropertyDescriptor? ?: WrappedPropertyDescriptor() ) - IrKlibProtoBuf.IrSymbolKind.FUNCTION_SYMBOL -> + KotlinIr.IrSymbolKind.FUNCTION_SYMBOL -> symbolTable.referenceSimpleFunction( descriptor as FunctionDescriptor? ?: WrappedSimpleFunctionDescriptor() ) - IrKlibProtoBuf.IrSymbolKind.VARIABLE_SYMBOL -> + KotlinIr.IrSymbolKind.VARIABLE_SYMBOL -> IrVariableSymbolImpl( descriptor as VariableDescriptor? ?: WrappedVariableDescriptor() ) - IrKlibProtoBuf.IrSymbolKind.VALUE_PARAMETER_SYMBOL -> + KotlinIr.IrSymbolKind.VALUE_PARAMETER_SYMBOL -> IrValueParameterSymbolImpl( descriptor as ParameterDescriptor? ?: WrappedValueParameterDescriptor() ) - IrKlibProtoBuf.IrSymbolKind.RECEIVER_PARAMETER_SYMBOL -> + KotlinIr.IrSymbolKind.RECEIVER_PARAMETER_SYMBOL -> IrValueParameterSymbolImpl( descriptor as ParameterDescriptor? ?: WrappedReceiverParameterDescriptor() ) else -> TODO("Unexpected classifier symbol kind: ${proto.kind}") } - override fun deserializeIrSymbol(proto: IrKlibProtoBuf.IrSymbol): IrSymbol { + override fun deserializeIrSymbol(proto: KotlinIr.IrSymbol): IrSymbol { val symbolData = deserializedModuleProtoSymbolTables[deserializedModuleDescriptor]!!.getSymbols(proto.index) return deserializeIrSymbolData(symbolData) } - override fun deserializeIrType(proto: IrKlibProtoBuf.IrTypeIndex): IrType { + override fun deserializeIrType(proto: KotlinIr.IrTypeIndex): IrType { val typeData = deserializedModuleProtoTypeTables[deserializedModuleDescriptor]!!.getTypes(proto.index) return deserializeIrTypeData(typeData) } - override fun deserializeString(proto: IrKlibProtoBuf.String) = + override fun deserializeString(proto: KotlinIr.String) = deserializedModuleProtoStringTables[deserializedModuleDescriptor]!!.getStrings(proto.index) - fun deserializeIrSymbolData(proto: IrKlibProtoBuf.IrSymbolData): IrSymbol { + override fun deserializeLoopHeader(loopIndex: Int, loopBuilder: () -> IrLoopBase) = + deserializedModuleLoops.getOrPut(deserializedModuleDescriptor!! to loopIndex, loopBuilder) + + fun deserializeIrSymbolData(proto: KotlinIr.IrSymbolData): IrSymbol { val key = proto.uniqId.uniqIdKey(deserializedModuleDescriptor!!) val topLevelKey = proto.topLevelUniqId.uniqIdKey(deserializedModuleDescriptor!!) @@ -168,10 +147,9 @@ class IrKlibProtoBufModuleDeserializer( referenceDeserializedSymbol(proto, descriptor) } - if (symbol.descriptor is ClassDescriptor && - symbol.descriptor !is WrappedDeclarationDescriptor<*>/* && - symbol.descriptor.module.isForwardDeclarationModule*/ + symbol.descriptor !is WrappedDeclarationDescriptor<*> && + symbol.descriptor.module.isForwardDeclarationModule ) { forwardDeclarations.add(symbol) } @@ -179,7 +157,7 @@ class IrKlibProtoBufModuleDeserializer( return symbol } - override fun deserializeDescriptorReference(proto: IrKlibProtoBuf.DescriptorReference) = + override fun deserializeDescriptorReference(proto: KotlinIr.DescriptorReference) = descriptorReferenceDeserializer.deserializeDescriptorReference( deserializeString(proto.packageFqName), deserializeString(proto.classFqName), @@ -209,16 +187,18 @@ class IrKlibProtoBufModuleDeserializer( val proto = loadTopLevelDeclarationProto(uniqIdKey) return deserializeDeclaration(proto, reversedFileIndex[uniqIdKey]!!) } + protected abstract fun reader(moduleDescriptor: ModuleDescriptor, uniqId: UniqId): ByteArray - private fun loadTopLevelDeclarationProto(uniqIdKey: UniqIdKey): IrKlibProtoBuf.IrDeclaration { - val file = File(irDirectory(deserializedModuleDescriptor!!), uniqIdKey.uniqId.declarationFileName) - return IrKlibProtoBuf.IrDeclaration.parseFrom(file.readBytes().codedInputStream, JsKlibMetadataSerializerProtocol.extensionRegistry) + private fun loadTopLevelDeclarationProto(uniqIdKey: UniqIdKey): KotlinIr.IrDeclaration { + val stream = reader(uniqIdKey.moduleOfOrigin!!, uniqIdKey.uniqId).codedInputStream + return KotlinIr.IrDeclaration.parseFrom(stream, newInstance()) } private fun findDeserializedDeclarationForDescriptor(descriptor: DeclarationDescriptor): DeclarationDescriptor? { val topLevelDescriptor = descriptor.findTopLevelDescriptor() -// if (topLevelDescriptor.module.isForwardDeclarationModule) return null + // This is Native specific. Try to eliminate. + if (topLevelDescriptor.module.isForwardDeclarationModule) return null if (topLevelDescriptor !is DeserializedClassDescriptor && topLevelDescriptor !is DeserializedCallableMemberDescriptor) { return null @@ -226,7 +206,7 @@ class IrKlibProtoBufModuleDeserializer( val descriptorUniqId = topLevelDescriptor.getUniqId() ?: error("could not get descriptor uniq id for $topLevelDescriptor") - val uniqId = UniqId(descriptorUniqId.index, isLocal = false) + val uniqId = UniqId(descriptorUniqId, isLocal = false) val topLevelKey = UniqIdKey(topLevelDescriptor.module, uniqId) // This top level descriptor doesn't have a serialized IR declaration. @@ -313,7 +293,7 @@ class IrKlibProtoBufModuleDeserializer( } } - fun deserializeIrFile(fileProto: IrKlibProtoBuf.IrFile, moduleDescriptor: ModuleDescriptor, deserializeAllDeclarations: Boolean): IrFile { + fun deserializeIrFile(fileProto: KotlinIr.IrFile, moduleDescriptor: ModuleDescriptor, deseralizationStrategy: DeserializationStrategy): IrFile { val fileEntry = NaiveSourceBasedFileEntryImpl( deserializeString(fileProto.fileEntry.name), fileProto.fileEntry.lineStartOffsetsList.toIntArray() @@ -331,15 +311,22 @@ class IrKlibProtoBufModuleDeserializer( val uniqIdKey = it.uniqIdKey(moduleDescriptor) reversedFileIndex.put(uniqIdKey, file) - if (deserializeAllDeclarations) { + if (deseralizationStrategy == DeserializationStrategy.ALL) { file.declarations.add(deserializeTopLevelDeclaration(uniqIdKey)) } } + val annotations = deserializeAnnotations(fileProto.annotations) + file.annotations.addAll(annotations) + + + if (deseralizationStrategy == DeserializationStrategy.EXPLICITLY_EXPORTED) + fileProto.explicitlyExportedToCompilerList.forEach { deserializeIrSymbol(it) } + return file } - fun deserializeIrModule(proto: IrKlibProtoBuf.IrModule, moduleDescriptor: ModuleDescriptor, deserializeAllDeclarations: Boolean): IrModuleFragment { + fun deserializeIrModuleHeader(proto: KotlinIr.IrModule, moduleDescriptor: ModuleDescriptor, deserializationStrategy: DeserializationStrategy): IrModuleFragment { deserializedModuleDescriptor = moduleDescriptor deserializedModuleProtoSymbolTables.put(moduleDescriptor, proto.symbolTable) @@ -347,16 +334,21 @@ class IrKlibProtoBufModuleDeserializer( deserializedModuleProtoTypeTables.put(moduleDescriptor, proto.typeTable) val files = proto.fileList.map { - deserializeIrFile(it, moduleDescriptor, deserializeAllDeclarations) + deserializeIrFile(it, moduleDescriptor, deserializationStrategy) } val module = IrModuleFragmentImpl(moduleDescriptor, builtIns, files) module.patchDeclarationParents(null) return module } - fun deserializeIrModule(moduleDescriptor: ModuleDescriptor, byteArray: ByteArray, klibLocation: File, deserializeAllDeclarations: Boolean = false): IrModuleFragment { - descriptorToDirectoryMap[moduleDescriptor] = File(klibLocation, "ir/") - val proto = IrKlibProtoBuf.IrModule.parseFrom(byteArray.codedInputStream, JsKlibMetadataSerializerProtocol.extensionRegistry) - return deserializeIrModule(proto, moduleDescriptor, deserializeAllDeclarations) + fun deserializeIrModuleHeader(moduleDescriptor: ModuleDescriptor, byteArray: ByteArray, deserializationStrategy: DeserializationStrategy = DeserializationStrategy.ONLY_REFERENCED): IrModuleFragment { + val proto = KotlinIr.IrModule.parseFrom(byteArray.codedInputStream, newInstance()) + return deserializeIrModuleHeader(proto, moduleDescriptor, deserializationStrategy) } -} \ No newline at end of file +} + +enum class DeserializationStrategy { + ONLY_REFERENCED, + ALL, + EXPLICITLY_EXPORTED +} diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinMangler.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinMangler.kt new file mode 100644 index 00000000000..37703d26e5c --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinMangler.kt @@ -0,0 +1,265 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.backend.common.serialization + +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.ir.backend.common.serialization.* +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol +import org.jetbrains.kotlin.ir.types.* +import org.jetbrains.kotlin.ir.util.isInlined +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name + +interface KotlinMangler { + val String.hashMangle: Long + val IrDeclaration.hashedMangle: Long + fun IrDeclaration.isExported(): Boolean + val IrFunction.functionName: String + +} + +abstract class KotlinManglerImpl: KotlinMangler { + override val IrDeclaration.hashedMangle: Long + get() = this.uniqSymbolName().hashMangle + + + // We can't call "with (super) { this.isExported() }" in children. + // So provide a hook. + protected open fun IrDeclaration.isPlatformSpecificExported(): Boolean = false + + /** + * Defines whether the declaration is exported, i.e. visible from other modules. + * + * Exported declarations must have predictable and stable ABI + * that doesn't depend on any internal transformations (e.g. IR lowering), + * and so should be computable from the descriptor itself without checking a backend state. + */ + override tailrec fun IrDeclaration.isExported(): Boolean { + // TODO: revise + val descriptorAnnotations = this.descriptor.annotations + + if (this.isPlatformSpecificExported()) return true + + if (descriptorAnnotations.hasAnnotation(publishedApiAnnotation)) { + return true + } + + if (this.isAnonymousObject) + return false + + if (this is IrConstructor && constructedClass.kind.isSingleton) { + // Currently code generator can access the constructor of the singleton, + // so ignore visibility of the constructor itself. + return constructedClass.isExported() + } + + if (this is IrFunction) { + val descriptor = this.descriptor + // TODO: this code is required because accessor doesn't have a reference to property. + if (descriptor is PropertyAccessorDescriptor) { + val property = descriptor.correspondingProperty + if (property.annotations.hasAnnotation(publishedApiAnnotation)) return true + } + } + + val visibility = when (this) { + is IrClass -> this.visibility + is IrFunction -> this.visibility + is IrProperty -> this.visibility + is IrField -> this.visibility + else -> null + } + + /** + * note: about INTERNAL - with support of friend modules we let frontend to deal with internal declarations. + */ + if (visibility != null && !visibility.isPublicAPI && visibility != Visibilities.INTERNAL) { + // If the declaration is explicitly marked as non-public, + // then it must not be accessible from other modules. + return false + } + + val parent = this.parent + if (parent is IrDeclaration) { + return parent.isExported() + } + + return true + } + + private val publishedApiAnnotation = FqName("kotlin.PublishedApi") + + protected fun acyclicTypeMangler(visited: MutableSet, type: IrType): String { + val descriptor = (type.classifierOrNull as? IrTypeParameterSymbol)?.owner + if (descriptor != null) { + val upperBounds = if (visited.contains(descriptor)) "" else { + + visited.add(descriptor) + + descriptor.superTypes.map { + val bound = acyclicTypeMangler(visited, it) + if (bound == "kotlin.Any?") "" else "_$bound" + }.joinToString("") + } + return "#GENERIC${if (type.isMarkedNullable()) "?" else ""}$upperBounds" + } + + var hashString = type.getClass()?.run { fqNameSafe.asString() } ?: "" + + when (type) { + is IrSimpleType -> { + if (!type.arguments.isEmpty()) { + hashString += "<${type.arguments.map { + when (it) { + is IrStarProjection -> "#STAR" + is IrTypeProjection -> { + val variance = it.variance.label + val projection = if (variance == "") "" else "${variance}_" + projection + acyclicTypeMangler(visited, it.type) + } + else -> error(it) + } + }.joinToString(",")}>" + } + + if (type.hasQuestionMark) hashString += "?" + } + !is IrDynamicType -> { + error(type) + } + } + return hashString + } + + protected fun typeToHashString(type: IrType) = acyclicTypeMangler(mutableSetOf(), type) + + val IrValueParameter.extensionReceiverNamePart: String + get() = "@${typeToHashString(this.type)}." + + open val IrFunction.argsPart get() = this.valueParameters.map { + "${typeToHashString(it.type)}${if (it.isVararg) "_VarArg" else ""}" + }.joinToString(";") + + open val IrFunction.signature: String + get() { + val extensionReceiverPart = this.extensionReceiverParameter?.extensionReceiverNamePart ?: "" + val argsPart = this.argsPart + // Distinguish value types and references - it's needed for calling virtual methods through bridges. + // Also is function has type arguments - frontend allows exactly matching overrides. + val signatureSuffix = + when { + this.typeParameters.isNotEmpty() -> "Generic" + returnType.isInlined() -> "ValueType" + !returnType.isUnitOrNullableUnit() -> typeToHashString(returnType) + else -> "" + } + return "$extensionReceiverPart($argsPart)$signatureSuffix" + } + + open val IrFunction.platformSpecificFunctionName: String? get() = null + + // TODO: rename to indicate that it has signature included + override val IrFunction.functionName: String + get() { + // TODO: Again. We can't call super in children, so provide a hook for now. + this.platformSpecificFunctionName ?. let { return it } + val name = this.name.mangleIfInternal(this.module, this.visibility) + return "$name$signature" + } + + fun Name.mangleIfInternal(moduleDescriptor: ModuleDescriptor, visibility: Visibility): String = + if (visibility != Visibilities.INTERNAL) { + this.asString() + } else { + val moduleName = moduleDescriptor.name.asString() + .let { it.substring(1, it.lastIndex) } // Remove < and >. + + "$this\$$moduleName" + } + + val IrField.symbolName: String + get() { + val containingDeclarationPart = parent.fqNameSafe.let { + if (it.isRoot) "" else "$it." + } + return "kfield:$containingDeclarationPart$name" + + } + + val IrClass.typeInfoSymbolName: String + get() { + assert(this.isExported()) + return "ktype:" + this.fqNameSafe.toString() + } + + +// This is a little extension over what's used in real mangling +// since some declarations never appear in the bitcode symbols. + + internal fun IrDeclaration.uniqSymbolName(): String = when (this) { + is IrFunction + -> this.uniqFunctionName + is IrProperty + -> this.symbolName + is IrClass + -> this.typeInfoSymbolName + is IrField + -> this.symbolName + is IrEnumEntry + -> this.symbolName + else -> error("Unexpected exported declaration: $this") + } + + private val IrDeclarationParent.fqNameUnique: FqName + get() = when (this) { + is IrPackageFragment -> this.fqName + is IrDeclaration -> this.parent.fqNameUnique.child(this.uniqName) + else -> error(this) + } + + private val IrDeclaration.uniqName: Name + get() = when (this) { + is IrSimpleFunction -> Name.special("<${this.uniqFunctionName}>") + else -> this.name + } + + private val IrProperty.symbolName: String + get() { + val extensionReceiver: String = getter!!.extensionReceiverParameter?.extensionReceiverNamePart ?: "" + + val containingDeclarationPart = parent.fqNameSafe.let { + if (it.isRoot) "" else "$it." + } + return "kprop:$containingDeclarationPart$extensionReceiver$name" + } + + private val IrEnumEntry.symbolName: String + get() { + val containingDeclarationPart = parent.fqNameSafe.let { + if (it.isRoot) "" else "$it." + } + return "kenumentry:$containingDeclarationPart$name" + } + + // This is basicly the same as .symbolName, but disambiguates external functions with the same C name. +// In addition functions appearing in fq sequence appear as . + private val IrFunction.uniqFunctionName: String + get() { + val parent = this.parent + + val containingDeclarationPart = parent.fqNameUnique.let { + if (it.isRoot) "" else "$it." + } + + return "kfun:$containingDeclarationPart#$functionName" + } + + +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/LegacyDescriptorUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/LegacyDescriptorUtils.kt similarity index 60% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/LegacyDescriptorUtils.kt rename to compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/LegacyDescriptorUtils.kt index 22c8d9365a7..5888100681d 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/LegacyDescriptorUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/LegacyDescriptorUtils.kt @@ -3,7 +3,7 @@ * that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +package org.jetbrains.kotlin.backend.common.serialization import org.jetbrains.kotlin.backend.common.descriptors.propertyIfAccessor import org.jetbrains.kotlin.descriptors.ClassDescriptor @@ -11,6 +11,9 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.MemberDescriptor import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.OverridingUtil internal val DeclarationDescriptor.isExpectMember: Boolean get() = this is MemberDescriptor && this.isExpect @@ -26,4 +29,23 @@ tailrec internal fun DeclarationDescriptor.findPackage(): PackageFragmentDescrip fun DeclarationDescriptor.findTopLevelDescriptor(): DeclarationDescriptor { return if (this.containingDeclaration is org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor) this.propertyIfAccessor else this.containingDeclaration!!.findTopLevelDescriptor() -} \ No newline at end of file +} + +/** + * TODO: this method is actually a part of resolve and probably duplicates another one + */ +internal fun T.resolveFakeOverrideMaybeAbstract(): Set { + if (this.kind.isReal) { + return setOf(this) + } else { + val overridden = OverridingUtil.getOverriddenDeclarations(this) + val filtered = OverridingUtil.filterOutOverridden(overridden) + // TODO: is it correct to take first? + @Suppress("UNCHECKED_CAST") + return filtered as Set + } +} + +// This is Native specific. Try to eliminate. +val ModuleDescriptor.isForwardDeclarationModule get() = + name == Name.special("") diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/SerializeDescriptorReference.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/SerializeDescriptorReference.kt similarity index 89% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/SerializeDescriptorReference.kt rename to compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/SerializeDescriptorReference.kt index 88e0aeaa5c3..04e4dff121a 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/SerializeDescriptorReference.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/SerializeDescriptorReference.kt @@ -3,24 +3,28 @@ * that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +package org.jetbrains.kotlin.backend.common.serialization import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.resolve.descriptorUtil.classId -class DescriptorReferenceSerializer(val declarationTable: DeclarationTable, val serializeString: (String) -> IrKlibProtoBuf.String) { +open class DescriptorReferenceSerializer( + val declarationTable: DeclarationTable, + val serializeString: (String) -> KotlinIr.String, + mangler: KotlinMangler): KotlinMangler by mangler { // Not all exported descriptors are deserialized, some a synthesized anew during metadata deserialization. // Those created descriptors can't carry the uniqIdIndex, since it is available only for deserialized descriptors. // So we record the uniq id of some other "discoverable" descriptor for which we know for sure that it will be // available as deserialized descriptor, plus the path to find the needed descriptor from that one. - fun serializeDescriptorReference(declaration: IrDeclaration): IrKlibProtoBuf.DescriptorReference? { + fun serializeDescriptorReference(declaration: IrDeclaration): KotlinIr.DescriptorReference? { val descriptor = declaration.descriptor - if (!declaration.isExported() && !((declaration as? IrDeclarationWithVisibility)?.visibility == Visibilities.INVISIBLE_FAKE)) { + if (!declaration.isExported() && + !((declaration as? IrDeclarationWithVisibility)?.visibility == Visibilities.INVISIBLE_FAKE)) { return null } if (declaration is IrAnonymousInitializer) return null @@ -71,7 +75,7 @@ class DescriptorReferenceSerializer(val declarationTable: DeclarationTable, val val uniqId = discoverableDescriptorsDeclaration?.let { declarationTable.uniqIdByDeclaration(it) } uniqId?.let { declarationTable.descriptors.put(discoverableDescriptorsDeclaration.descriptor, it) } - val proto = IrKlibProtoBuf.DescriptorReference.newBuilder() + val proto = KotlinIr.DescriptorReference.newBuilder() .setPackageFqName(serializeString(packageFqName)) .setClassFqName(serializeString(classFqName)) .setName(serializeString(descriptor.name.toString())) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/UniqId.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/UniqId.kt new file mode 100644 index 00000000000..4ca2a944e8d --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/UniqId.kt @@ -0,0 +1,48 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.backend.common.serialization + +import org.jetbrains.kotlin.descriptors.* +//import org.jetbrains.kotlin.ir.backend.js.lower.serialization.metadata.JsKlibMetadataProtoBuf +import org.jetbrains.kotlin.protobuf.GeneratedMessageLite + +// This is an abstract uniqIdIndex any serialized IR declarations gets. +// It is either isLocal and then just gets and ordinary number within its module. +// Or is visible across modules and then gets a hash of mangled name as its index. +data class UniqId ( + val index: Long, + val isLocal: Boolean +) + +// isLocal=true in UniqId is good while we dealing with a single current module. +// To disambiguate module local declarations of different modules we use UniqIdKey. +// It has moduleDescriptor specified for isLocal=true uniqIds. + +// TODO: make sure UniqId is really uniq for any global declaration + +data class UniqIdKey private constructor(val uniqId: UniqId, val moduleDescriptor: ModuleDescriptor?) { + constructor(moduleDescriptor: ModuleDescriptor?, uniqId: UniqId) + : this(uniqId, if (uniqId.isLocal) moduleDescriptor!! else null) +} + +fun protoUniqId(uniqId: UniqId): KotlinIr.UniqId = + KotlinIr.UniqId.newBuilder() + .setIndex(uniqId.index) + .setIsLocal(uniqId.isLocal) + .build() + +fun KotlinIr.UniqId.uniqId(): UniqId = UniqId(this.index, this.isLocal) +fun KotlinIr.UniqId.uniqIdKey(moduleDescriptor: ModuleDescriptor) = + UniqIdKey(moduleDescriptor, this.uniqId()) + +fun > M.tryGetExtension(extension: GeneratedMessageLite.GeneratedExtension) + = if (this.hasExtension(extension)) this.getExtension(extension) else null + +interface DescriptorUniqIdAware { + fun DeclarationDescriptor.getUniqId(): Long? +} + +//val UniqId.declarationFileName: String get() = "$index${if (isLocal) "L" else "G"}.kjd" diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/UniqSymbolName.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/UniqSymbolName.kt new file mode 100644 index 00000000000..e9e570fa130 --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/UniqSymbolName.kt @@ -0,0 +1,10 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.ir.backend.common.serialization + +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt index 2d7238d8efd..71d1e79a614 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.ir.backend.js import com.intellij.openapi.project.Project import org.jetbrains.kotlin.backend.common.LoggingContext import org.jetbrains.kotlin.backend.common.phaser.invokeToplevel +import org.jetbrains.kotlin.backend.common.serialization.DeserializationStrategy import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.functions.functionInterfacePackageFragmentProvider import org.jetbrains.kotlin.config.CommonConfigurationKeys @@ -17,8 +18,12 @@ import org.jetbrains.kotlin.config.languageVersionSettings import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.incremental.components.LookupTracker +import org.jetbrains.kotlin.backend.common.serialization.DescriptorTable import org.jetbrains.kotlin.ir.backend.js.lower.inline.replaceUnboundSymbols -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.* +import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsDeclarationTable +import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker +import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrModuleSerializer +import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.newJsDescriptorUniqId import org.jetbrains.kotlin.ir.backend.js.lower.serialization.metadata.JsKlibMetadataModuleDescriptor import org.jetbrains.kotlin.ir.backend.js.lower.serialization.metadata.JsKlibMetadataSerializationUtil import org.jetbrains.kotlin.ir.backend.js.lower.serialization.metadata.JsKlibMetadataVersion @@ -38,6 +43,9 @@ import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.utils.DFS import java.io.File +import java.nio.file.Files +import java.nio.file.Paths +import java.nio.file.StandardCopyOption class CompiledModule( val moduleName: String, @@ -56,7 +64,6 @@ enum class CompilationMode(val generateJS: Boolean, val generateKlib: Boolean) { private val moduleHeaderFileName = "module.kji" private val declarationsDirName = "ir/" -private val debugDataFileName = "debug.txt" private val logggg = object : LoggingContext { override var inVerbosePhase: Boolean get() = TODO("not implemented") @@ -73,7 +80,7 @@ data class JsKlib( val moduleIr: IrModuleFragment, val symbolTable: SymbolTable, val irBuiltIns: IrBuiltIns, - val deserializer: IrKlibProtoBufModuleDeserializer + val deserializer: JsIrLinker ) @@ -108,14 +115,14 @@ private fun deserializeModuleFromKlib( val irBuiltIns = IrBuiltIns(md.builtIns, typeTranslator, st) val moduleFile = File(klibDirFile, moduleHeaderFileName) - val deserializer = IrKlibProtoBufModuleDeserializer(md, logggg, irBuiltIns, st, null) + val deserializer = JsIrLinker(md, logggg, irBuiltIns, st) dependencies.forEach { val dependencyKlibDir = File(it.klibPath, moduleHeaderFileName) - deserializer.deserializeIrModule(it.moduleDescriptor!!, dependencyKlibDir.readBytes(), File(it.klibPath), false) + deserializer.deserializeIrModuleHeader(it.moduleDescriptor!!, dependencyKlibDir.readBytes(), File(it.klibPath), DeserializationStrategy.ONLY_REFERENCED) } - val moduleFragment = deserializer.deserializeIrModule(md, moduleFile.readBytes(), klibDirFile, true) + val moduleFragment = deserializer.deserializeIrModuleHeader(md, moduleFile.readBytes(), klibDirFile, DeserializationStrategy.ALL) return JsKlib(md, moduleFragment, st, irBuiltIns, deserializer) } @@ -160,11 +167,11 @@ fun compile( val psi2IrContext = psi2IrTranslator.createGeneratorContext(moduleDescriptor, analysisResult.bindingContext, symbolTable) val irBuiltIns = psi2IrContext.irBuiltIns - var deserializer = IrKlibProtoBufModuleDeserializer(moduleDescriptor, logggg, irBuiltIns, symbolTable, null) + var deserializer = JsIrLinker(moduleDescriptor, logggg, irBuiltIns, symbolTable) val deserializedModuleFragments = sortedDeps.map { val moduleFile = File(it.klibPath, moduleHeaderFileName) - deserializer.deserializeIrModule(it.moduleDescriptor!!, moduleFile.readBytes(), File(it.klibPath), false) + deserializer.deserializeIrModuleHeader(it.moduleDescriptor!!, moduleFile.readBytes(), File(it.klibPath), DeserializationStrategy.ONLY_REFERENCED) } var moduleFragment = psi2IrTranslator.generateModuleFragment(psi2IrContext, files, deserializer) @@ -321,9 +328,9 @@ fun serializeModuleIntoKlib( dependencies: List, moduleFragment: IrModuleFragment ) { - val declarationTable = DeclarationTable(moduleFragment.irBuiltins, DescriptorTable(), symbolTable) + val declarationTable = JsDeclarationTable(moduleFragment.irBuiltins, DescriptorTable()).apply { loadKnownBuiltins() } - val serializedIr = IrModuleSerializer(logggg, declarationTable/*, onlyForInlines = false*/).serializedIrModule(moduleFragment) + val serializedIr = JsIrModuleSerializer(logggg, declarationTable).serializedIrModule(moduleFragment) val serializer = JsKlibMetadataSerializationUtil val moduleDescription = @@ -335,7 +342,7 @@ fun serializeModuleIntoKlib( metadataVersion ) { declarationDescriptor -> val index = declarationTable.descriptorTable.get(declarationDescriptor) - index?.let { newDescriptorUniqId(it) } + index?.let { newJsDescriptorUniqId(it) } } val klibDir = File(klibPath).also { @@ -347,20 +354,8 @@ fun serializeModuleIntoKlib( moduleFile.writeBytes(serializedIr.module) val irDeclarationDir = File(klibDir, declarationsDirName).also { it.mkdir() } - - for ((id, data) in serializedIr.declarations) { - val file = File(irDeclarationDir, id.declarationFileName) - file.writeBytes(data) - } - - val debugFile = File(klibDir, debugDataFileName) - - for ((id, data) in serializedIr.debugIndex) { - debugFile.appendText(id.toString()) - debugFile.appendText(" --- ") - debugFile.appendText(data) - debugFile.appendText("\n") - } + val irCombinedFile = File(irDeclarationDir, "irCombined.knd") + Files.copy(Paths.get(serializedIr.combinedDeclarationFilePath), Paths.get(irCombinedFile.path), StandardCopyOption.REPLACE_EXISTING) File(klibDir, "${moduleDescription.name}.${JsKlibMetadataSerializationUtil.CLASS_METADATA_FILE_EXTENSION}").also { it.writeBytes(serializedData.asByteArray()) diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/FunctionInlining.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/FunctionInlining.kt index 7a25dc8d7c5..d20b4ea51a0 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/FunctionInlining.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/FunctionInlining.kt @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.backend.common.IrElementTransformerVoidWithContext import org.jetbrains.kotlin.backend.common.ScopeWithIr import org.jetbrains.kotlin.backend.common.descriptors.explicitParameters import org.jetbrains.kotlin.backend.common.lower.createIrBuilder -import org.jetbrains.kotlin.backend.common.reportWarning import org.jetbrains.kotlin.config.languageVersionSettings import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.ValueDescriptor @@ -20,7 +19,6 @@ import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.fileEntry import org.jetbrains.kotlin.ir.builders.irCall import org.jetbrains.kotlin.ir.builders.irGet import org.jetbrains.kotlin.ir.builders.irReturn diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AdditionalIrUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AdditionalIrUtils.kt deleted file mode 100644 index 12d3b010913..00000000000 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AdditionalIrUtils.kt +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license - * that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir - -import org.jetbrains.kotlin.ir.SourceManager -import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.expressions.IrCall -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name - -val IrConstructor.constructedClass get() = this.parent as IrClass - -val T.original get() = this - -val IrDeclarationParent.fqNameSafe: FqName - get() = when (this) { - is IrPackageFragment -> this.fqName - is IrDeclaration -> this.parent.fqNameSafe.child(this.name) - - else -> error(this) - } - -val IrClass.classId: ClassId? - get() { - val parent = this.parent - return when (parent) { - is IrClass -> parent.classId?.createNestedClassId(this.name) - is IrPackageFragment -> ClassId.topLevel(parent.fqName.child(this.name)) - else -> null - } - } - -val IrDeclaration.name: Name - get() = when (this) { - is IrSimpleFunction -> this.name - is IrClass -> this.name - is IrEnumEntry -> this.name - is IrProperty -> this.name - is IrLocalDelegatedProperty -> this.name - is IrField -> this.name - is IrVariable -> this.name - is IrConstructor -> SPECIAL_INIT_NAME - is IrValueParameter -> this.name - else -> error(this) - } - -private val SPECIAL_INIT_NAME = Name.special("") - -val IrValueParameter.isVararg get() = this.varargElementType != null - -val IrFunction.isSuspend get() = this is IrSimpleFunction && this.isSuspend - -val IrFunction.isReal get() = this.origin != IrDeclarationOrigin.FAKE_OVERRIDE - -fun IrSimpleFunction.overrides(other: IrSimpleFunction): Boolean { - if (this == other) return true - - this.overriddenSymbols.forEach { - if (it.owner.overrides(other)) { - return true - } - } - - return false -} - -private val IrCall.annotationClass - get() = (this.symbol.owner as IrConstructor).constructedClass - -fun List.hasAnnotation(fqName: FqName): Boolean = - this.any { it.annotationClass.fqNameSafe == fqName } - -fun IrAnnotationContainer.hasAnnotation(fqName: FqName) = - this.annotations.hasAnnotation(fqName) - -fun List.findAnnotation(fqName: FqName): IrCall? = this.firstOrNull { - it.annotationClass.fqNameSafe == fqName -} - -fun IrClass.companionObject() = this.declarations.singleOrNull {it is IrClass && it.isCompanion } - -val IrDeclaration.isGetter get() = this is IrSimpleFunction && this == this.correspondingProperty?.getter - -val IrDeclaration.isSetter get() = this is IrSimpleFunction && this == this.correspondingProperty?.setter - -val IrDeclaration.isAccessor get() = this.isGetter || this.isSetter - -val IrDeclaration.fileEntry: SourceManager.FileEntry - get() = parent.let { - when (it) { - is IrFile -> it.fileEntry - is IrPackageFragment -> TODO("Unknown file") - is IrDeclaration -> it.fileEntry - else -> TODO("Unexpected declaration parent") - } - } \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AnotherIrUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AnotherIrUtils.kt index 79bc5984027..53be135af3f 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AnotherIrUtils.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AnotherIrUtils.kt @@ -5,13 +5,12 @@ package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir +import org.jetbrains.kotlin.backend.common.serialization.fqNameSafe +import org.jetbrains.kotlin.backend.common.serialization.name import org.jetbrains.kotlin.builtins.functions.FunctionInvokeDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor -import org.jetbrains.kotlin.ir.SourceManager -import org.jetbrains.kotlin.ir.SourceRangeInfo -import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.declarations.IrDeclaration import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction @@ -19,75 +18,8 @@ import org.jetbrains.kotlin.ir.util.parentAsClass import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi2ir.findFirstFunction -import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.descriptorUtil.module -import java.io.File import java.util.regex.Pattern -internal val IrDeclaration.isAnonymousObject get() = DescriptorUtils.isAnonymousObject(this.descriptor) -internal val IrDeclaration.isLocal get() = DescriptorUtils.isLocal(this.descriptor) - -internal val IrDeclaration.module get() = this.descriptor.module - -internal const val SYNTHETIC_OFFSET = -2 - -val File.lineStartOffsets: IntArray - get() { - // TODO: could be incorrect, if file is not in system's line terminator format. - // Maybe use (0..document.lineCount - 1) - // .map { document.getLineStartOffset(it) } - // .toIntArray() - // as in PSI. - val separatorLength = System.lineSeparator().length - val buffer = mutableListOf() - var currentOffset = 0 - this.forEachLine { line -> - buffer.add(currentOffset) - currentOffset += line.length + separatorLength - } - buffer.add(currentOffset) - return buffer.toIntArray() - } - -val SourceManager.FileEntry.lineStartOffsets - get() = File(name).let { - if (it.exists() && it.isFile) it.lineStartOffsets else IntArray(0) - } - -class NaiveSourceBasedFileEntryImpl(override val name: String, val lineStartOffsets: IntArray = IntArray(0)) : SourceManager.FileEntry { - - //-------------------------------------------------------------------------// - - override fun getLineNumber(offset: Int): Int { - assert(offset != UNDEFINED_OFFSET) - if (offset == SYNTHETIC_OFFSET) return 0 - val index = lineStartOffsets.binarySearch(offset) - return if (index >= 0) index else -index - 2 - } - - //-------------------------------------------------------------------------// - - override fun getColumnNumber(offset: Int): Int { - assert(offset != UNDEFINED_OFFSET) - if (offset == SYNTHETIC_OFFSET) return 0 - var lineNumber = getLineNumber(offset) - return offset - lineStartOffsets[lineNumber] - } - - //-------------------------------------------------------------------------// - - override val maxOffset: Int - //get() = TODO("not implemented") - get() = UNDEFINED_OFFSET - - override fun getSourceRangeInfo(beginOffset: Int, endOffset: Int): SourceRangeInfo { - //TODO("not implemented") - return SourceRangeInfo(name, beginOffset, -1, -1, endOffset, -1, -1) - - } -} - - private val functionPattern = Pattern.compile("^K?(Suspend)?Function\\d+$") private val kotlinFqn = FqName("kotlin") @@ -158,4 +90,4 @@ internal fun builtInFunctionId(value: DeclarationDescriptor): Long = when (value BUILT_IN_UNIQ_ID_CLASS_OFFSET + builtInFunctionId(value.findFirstFunction("invoke") { true }) } else -> error("Only class or function is expected") -} \ No newline at end of file +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/BinaryInterface.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/BinaryInterface.kt deleted file mode 100644 index c811f88fd73..00000000000 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/BinaryInterface.kt +++ /dev/null @@ -1,227 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license - * that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir - -import org.jetbrains.kotlin.descriptors.ModuleDescriptor -import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor -import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.descriptors.Visibility -import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol -import org.jetbrains.kotlin.ir.types.* -import org.jetbrains.kotlin.ir.util.isInlined -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name - - -// This file describes the ABI for Kotlin descriptors of exported declarations. -// TODO: revise the naming scheme to ensure it produces unique names. -// TODO: do not serialize descriptors of non-exported declarations. - -/** - * Defines whether the declaration is exported, i.e. visible from other modules. - * - * Exported declarations must have predictable and stable ABI - * that doesn't depend on any internal transformations (e.g. IR lowering), - * and so should be computable from the descriptor itself without checking a backend state. - */ -internal tailrec fun IrDeclaration.isExported(): Boolean { - // TODO: revise - val descriptorAnnotations = this.descriptor.annotations -// if (descriptorAnnotations.hasAnnotation(symbolNameAnnotation)) { -// // Treat any `@SymbolName` declaration as exported. -// return true -// } -// if (descriptorAnnotations.hasAnnotation(exportForCppRuntimeAnnotation)) { -// // Treat any `@ExportForCppRuntime` declaration as exported. -// return true -// } -// if (descriptorAnnotations.hasAnnotation(cnameAnnotation)) { -// // Treat `@CName` declaration as exported. -// return true -// } -// if (descriptorAnnotations.hasAnnotation(exportForCompilerAnnotation)) { -// return true -// } - if (descriptorAnnotations.hasAnnotation(publishedApiAnnotation)){ - return true - } - - if (this.isAnonymousObject) - return false - - if (this is IrConstructor && constructedClass.kind.isSingleton) { - // Currently code generator can access the constructor of the singleton, - // so ignore visibility of the constructor itself. - return constructedClass.isExported() - } - - if (this is IrFunction) { - val descriptor = this.descriptor - // TODO: this code is required because accessor doesn't have a reference to property. - if (descriptor is PropertyAccessorDescriptor) { - val property = descriptor.correspondingProperty - if (property.annotations.hasAnnotation(publishedApiAnnotation)) return true - } - } - - val visibility = when (this) { - is IrClass -> this.visibility - is IrFunction -> this.visibility - is IrProperty -> this.visibility - is IrField -> this.visibility - else -> null - } - - /** - * note: about INTERNAL - with support of friend modules we let frontend to deal with internal declarations. - */ - if (visibility != null && !visibility.isPublicAPI && visibility != Visibilities.INTERNAL) { - // If the declaration is explicitly marked as non-public, - // then it must not be accessible from other modules. - return false - } - - val parent = this.parent - if (parent is IrDeclaration) { - return parent.isExported() - } - - return true -} - -private val publishedApiAnnotation = FqName("kotlin.PublishedApi") - -private fun acyclicTypeMangler(visited: MutableSet, type: IrType): String { - val descriptor = (type.classifierOrNull as? IrTypeParameterSymbol)?.owner - if (descriptor != null) { - val upperBounds = if (visited.contains(descriptor)) "" else { - - visited.add(descriptor) - - descriptor.superTypes.map { - val bound = acyclicTypeMangler(visited, it) - if (bound == "kotlin.Any?") "" else "_$bound" - }.joinToString("") - } - return "#GENERIC${if (type.isMarkedNullable()) "?" else ""}$upperBounds" - } - - var hashString = type.getClass()?.run { fqNameSafe.asString() } ?: "" -// if (type !is IrSimpleType) error(type) - when (type) { - is IrSimpleType -> { - if (!type.arguments.isEmpty()) { - hashString += "<${type.arguments.map { - when (it) { - is IrStarProjection -> "#STAR" - is IrTypeProjection -> { - val variance = it.variance.label - val projection = if (variance == "") "" else "${variance}_" - projection + acyclicTypeMangler(visited, it.type) - } - else -> error(it) - } - }.joinToString(",")}>" - } - - if (type.hasQuestionMark) hashString += "?" - } - !is IrDynamicType -> { error(type) } - } - return hashString -} - -private fun typeToHashString(type: IrType) = acyclicTypeMangler(mutableSetOf(), type) - -internal val IrValueParameter.extensionReceiverNamePart: String - get() = "@${typeToHashString(this.type)}." - -private val IrFunction.signature: String - get() { - val extensionReceiverPart = this.extensionReceiverParameter?.extensionReceiverNamePart ?: "" - val argsPart = this.valueParameters.map { - - // TODO: there are clashes originating from ObjectiveC interop. - // kotlinx.cinterop.ObjCClassOf.create(format: kotlin.String): T defined in platform.Foundation in file Foundation.kt - // and - // kotlinx.cinterop.ObjCClassOf.create(string: kotlin.String): T defined in platform.Foundation in file Foundation.kt - - val argName = /*if (this.hasObjCMethodAnnotation || this.hasObjCFactoryAnnotation || this.isObjCClassMethod()) "${it.name}:" else */"" - "$argName${typeToHashString(it.type)}${if (it.isVararg) "_VarArg" else ""}" - }.joinToString(";") - // Distinguish value types and references - it's needed for calling virtual methods through bridges. - // Also is function has type arguments - frontend allows exactly matching overrides. - val signatureSuffix = - when { - this.typeParameters.isNotEmpty() -> "Generic" - returnType.isInlined() -> "ValueType" - !returnType.isUnitOrNullableUnit() -> typeToHashString(returnType) - else -> "" - } - return "$extensionReceiverPart($argsPart)$signatureSuffix" - } - -// TODO: rename to indicate that it has signature included -internal val IrFunction.functionName: String - get() { - with(this.original) { // basic support for generics -// (if (this is IrConstructor && this.isObjCConstructor) this.getObjCInitMethod() else this)?.getObjCMethodInfo()?.let { -// return buildString { -// if (extensionReceiverParameter != null) { -// append(extensionReceiverParameter!!.type.getClass()!!.name) -// append(".") -// } -// -// append("objc:") -// append(it.selector) -// if (this@with is IrConstructor && this@with.isObjCConstructor) append("#Constructor") -// -// // We happen to have the clashing combinations such as -// //@ObjCMethod("issueChallengeToPlayers:message:", "objcKniBridge1165") -// //external fun GKScore.issueChallengeToPlayers(playerIDs: List<*>?, message: String?): Unit -// //@ObjCMethod("issueChallengeToPlayers:message:", "objcKniBridge1172") -// //external fun GKScore.issueChallengeToPlayers(playerIDs: List<*>?, message: String?): Unit -// // So disambiguate by the name of the bridge for now. -// // TODO: idealy we'd never generate such identical declarations. -// -// if (this@with is IrSimpleFunction && this@with.hasObjCMethodAnnotation()) { -// this@with.objCMethodArgValue("selector") ?.let { append("#$it") } -// this@with.objCMethodArgValue("bridge") ?.let { append("#$it") } -// } -// } -// } - - val name = this.name.mangleIfInternal(this.module, this.visibility) - - return "$name$signature" - } - } - -private fun Name.mangleIfInternal(moduleDescriptor: ModuleDescriptor, visibility: Visibility): String = - if (visibility != Visibilities.INTERNAL) { - this.asString() - } else { - val moduleName = moduleDescriptor.name.asString() - .let { it.substring(1, it.lastIndex) } // Remove < and >. - - "$this\$$moduleName" - } - -internal val IrField.symbolName: String - get() { - val containingDeclarationPart = parent.fqNameSafe.let { - if (it.isRoot) "" else "$it." - } - return "kfield:$containingDeclarationPart$name" - - } - -internal val IrClass.typeInfoSymbolName: String - get() { - assert (this.isExported()) - return "ktype:" + this.fqNameSafe.toString() - } \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrSerializationUtil.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrSerializationUtil.kt deleted file mode 100644 index 3c9bdb0a85c..00000000000 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrSerializationUtil.kt +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license - * that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir - -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.resolve.OverridingUtil - -// TODO: move me somewhere - -/** - * Implementation of given method. - * - * TODO: this method is actually a part of resolve and probably duplicates another one - */ -internal fun IrSimpleFunction.resolveFakeOverrideMaybeAbstract() = this.resolveFakeOverride(allowAbstract = true) - -internal fun IrProperty.resolveFakeOverrideMaybeAbstract() = this.getter!!.resolveFakeOverrideMaybeAbstract().correspondingProperty!! - -internal fun IrField.resolveFakeOverrideMaybeAbstract() = this.correspondingProperty!!.getter!!.resolveFakeOverrideMaybeAbstract().correspondingProperty!!.backingField - -/** - * Implementation of given method. - * - * TODO: this method is actually a part of resolve and probably duplicates another one - */ -internal fun T.resolveFakeOverrideMaybeAbstract(): Set { - if (this.kind.isReal) { - return setOf(this) - } else { - val overridden = OverridingUtil.getOverriddenDeclarations(this) - val filtered = OverridingUtil.filterOutOverridden(overridden) - // TODO: is it correct to take first? - @Suppress("UNCHECKED_CAST") - return filtered as Set - } -} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDeclarationTable.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDeclarationTable.kt new file mode 100644 index 00000000000..d81d155863d --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDeclarationTable.kt @@ -0,0 +1,26 @@ +package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir + +import org.jetbrains.kotlin.backend.common.serialization.UniqId +import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable +import org.jetbrains.kotlin.backend.common.serialization.DescriptorTable +import org.jetbrains.kotlin.ir.declarations.IrDeclaration +import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns + +class JsDeclarationTable(builtIns: IrBuiltIns, descriptorTable: DescriptorTable) + : DeclarationTable(builtIns, descriptorTable, JsMangler) { + + override var currentIndex = 0x1_0000_0000L + + private /* lateinit */ var FUNCTION_INDEX_START: Long = 0xdeadbeefL + + override fun loadKnownBuiltins() { + super.loadKnownBuiltins() + FUNCTION_INDEX_START = currentIndex + currentIndex += BUILT_IN_UNIQ_ID_GAP + } + + override fun computeUniqIdByDeclaration(value: IrDeclaration) = + if (isBuiltInFunction(value)) { + UniqId(FUNCTION_INDEX_START + builtInFunctionId(value), false) + } else super.computeUniqIdByDeclaration(value) +} \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDescriptorReferenceDeserializer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDescriptorReferenceDeserializer.kt new file mode 100644 index 00000000000..913530437bb --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDescriptorReferenceDeserializer.kt @@ -0,0 +1,33 @@ +package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir + +import org.jetbrains.kotlin.backend.common.serialization.DescriptorReferenceDeserializer +import org.jetbrains.kotlin.backend.common.serialization.DescriptorUniqIdAware +import org.jetbrains.kotlin.backend.common.serialization.UniqId +import org.jetbrains.kotlin.backend.common.serialization.UniqIdKey +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns +import org.jetbrains.kotlin.name.FqName + + +class JsDescriptorReferenceDeserializer( + currentModule: ModuleDescriptor, + val builtIns: IrBuiltIns, + val FUNCTION_INDEX_START: Long) : + DescriptorReferenceDeserializer(currentModule, mutableMapOf()), + DescriptorUniqIdAware by JsDescriptorUniqIdAware { + + val knownBuiltInsDescriptors = mutableMapOf() + + override fun resolveSpecialDescriptor(fqn: FqName) = builtIns.builtIns.getBuiltInClassByFqName(fqn) + + override fun checkIfSpecialDescriptorId(id: Long) = + (FUNCTION_INDEX_START + BUILT_IN_UNIQ_ID_CLASS_OFFSET) <= id && id < (FUNCTION_INDEX_START + BUILT_IN_UNIQ_ID_GAP) + + override fun getDescriptorIdOrNull(descriptor: DeclarationDescriptor) = + knownBuiltInsDescriptors[descriptor]?.index ?: if (isBuiltInFunction(descriptor)) + FUNCTION_INDEX_START + builtInFunctionId(descriptor) + else null + +} + diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDescriptorUniqIdAware.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDescriptorUniqIdAware.kt new file mode 100644 index 00000000000..097b1ef3ef9 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDescriptorUniqIdAware.kt @@ -0,0 +1,23 @@ +package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir + +import org.jetbrains.kotlin.backend.common.serialization.DescriptorUniqIdAware +import org.jetbrains.kotlin.backend.common.serialization.tryGetExtension +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.ir.backend.js.lower.serialization.metadata.JsKlibMetadataProtoBuf +import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassConstructorDescriptor +import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor +import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor +import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedSimpleFunctionDescriptor + +object JsDescriptorUniqIdAware: DescriptorUniqIdAware { + override fun DeclarationDescriptor.getUniqId(): Long? = when (this) { + is DeserializedClassDescriptor -> this.classProto.tryGetExtension(JsKlibMetadataProtoBuf.classUniqId) + is DeserializedSimpleFunctionDescriptor -> this.proto.tryGetExtension(JsKlibMetadataProtoBuf.functionUniqId) + is DeserializedPropertyDescriptor -> this.proto.tryGetExtension(JsKlibMetadataProtoBuf.propertyUniqId) + is DeserializedClassConstructorDescriptor -> this.proto.tryGetExtension(JsKlibMetadataProtoBuf.constructorUniqId) + else -> null + }?.index +} + +fun newJsDescriptorUniqId(index: Long): JsKlibMetadataProtoBuf.DescriptorUniqId = + JsKlibMetadataProtoBuf.DescriptorUniqId.newBuilder().setIndex(index).build() diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrLinker.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrLinker.kt new file mode 100644 index 00000000000..57e35744780 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrLinker.kt @@ -0,0 +1,59 @@ +package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir + +import org.jetbrains.kotlin.backend.common.LoggingContext +import org.jetbrains.kotlin.backend.common.library.CombinedIrFileReader +import org.jetbrains.kotlin.backend.common.library.DeclarationId +import org.jetbrains.kotlin.backend.common.serialization.* +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.backend.common.serialization.knownBuiltins +import org.jetbrains.kotlin.ir.declarations.IrFunction +import org.jetbrains.kotlin.ir.declarations.IrModuleFragment +import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns +import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol +import org.jetbrains.kotlin.ir.util.SymbolTable +import java.io.File + +class JsIrLinker( + currentModule: ModuleDescriptor, + logger: LoggingContext, + builtIns: IrBuiltIns, + symbolTable: SymbolTable) : + KotlinIrLinker(currentModule, logger, builtIns, symbolTable, null), + DescriptorUniqIdAware by JsDescriptorUniqIdAware { + + private val FUNCTION_INDEX_START: Long + val moduleToReaderMap = mutableMapOf() + + init { + // TODO: think about order + var currentIndex = 0x1_0000_0000L + builtIns.knownBuiltins.forEach { + require(it is IrFunction) + deserializedSymbols.put(UniqIdKey(null, UniqId(currentIndex, isLocal = false)), it.symbol) + assert(symbolTable.referenceSimpleFunction(it.descriptor) == it.symbol) + currentIndex++ + } + + FUNCTION_INDEX_START = currentIndex + } + + override fun getPrimitiveTypeOrNull(symbol: IrClassifierSymbol, hasQuestionMark: Boolean) = + builtIns.getPrimitiveTypeOrNullByDescriptor(symbol.descriptor, hasQuestionMark) + + override val descriptorReferenceDeserializer = + JsDescriptorReferenceDeserializer(currentModule, builtIns, FUNCTION_INDEX_START) + + override fun reader(moduleDescriptor: ModuleDescriptor, uniqId: UniqId) = + moduleToReaderMap[moduleDescriptor]!!.declarationBytes(DeclarationId(uniqId.index, uniqId.isLocal)) + + fun deserializeIrModuleHeader( + moduleDescriptor: ModuleDescriptor, + byteArray: ByteArray, + klibLocation: File, + deserializationStrategy: DeserializationStrategy + ): IrModuleFragment { + val irFile = File(klibLocation, "ir/irCombined.knd") + moduleToReaderMap[moduleDescriptor] = CombinedIrFileReader(irFile) + return deserializeIrModuleHeader(moduleDescriptor, byteArray, deserializationStrategy) + } +} \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrModuleSerializer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrModuleSerializer.kt new file mode 100644 index 00000000000..9c54c4cadfe --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrModuleSerializer.kt @@ -0,0 +1,11 @@ +package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir + +import org.jetbrains.kotlin.backend.common.LoggingContext +import org.jetbrains.kotlin.backend.common.serialization.IrModuleSerializer +import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable + +class JsIrModuleSerializer( + logger: LoggingContext, + declarationTable: DeclarationTable, + bodiesOnlyForInlines: Boolean = false +) : IrModuleSerializer(logger, declarationTable, JsMangler, bodiesOnlyForInlines) \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsMangler.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsMangler.kt new file mode 100644 index 00000000000..40aff5c84ea --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsMangler.kt @@ -0,0 +1,14 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir + +import org.jetbrains.kotlin.backend.common.serialization.KotlinManglerImpl + +object JsMangler: KotlinManglerImpl() { + // TODO: think about this + override val String.hashMangle: Long get() = this.hashCode().toLong() +} + diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqId.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqId.kt deleted file mode 100644 index 32202ef336b..00000000000 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqId.kt +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license - * that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir - -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.metadata.JsKlibMetadataProtoBuf -import org.jetbrains.kotlin.ir.declarations.IrDeclaration -import org.jetbrains.kotlin.serialization.deserialization.descriptors.* -import org.jetbrains.kotlin.protobuf.GeneratedMessageLite - -// This is an abstract uniqIdIndex any serialized IR declarations gets. -// It is either isLocal and then just gets and ordinary number within its module. -// Or is visible across modules and then gets a hash of mangled name as its index. -data class UniqId ( - val index: Long, - val isLocal: Boolean -) - -// isLocal=true in UniqId is good while we dealing with a single current module. -// To disambiguate module local declarations of different modules we use UniqIdKey. -// It has moduleDescriptor specified for isLocal=true uniqIds. - -// TODO: make sure UniqId is really uniq for any global declaration - -data class UniqIdKey private constructor(val uniqId: UniqId, val moduleDescriptor: ModuleDescriptor?) { - constructor(moduleDescriptor: ModuleDescriptor?, uniqId: UniqId) - : this(uniqId, if (uniqId.isLocal) moduleDescriptor!! else null) -} - -// TODO: think about this -internal val IrDeclaration.uniqIdIndex: Long - get() = this.uniqSymbolName().hashCode().toLong() - -fun protoUniqId(uniqId: UniqId): IrKlibProtoBuf.UniqId = - IrKlibProtoBuf.UniqId.newBuilder() - .setIndex(uniqId.index) - .setIsLocal(uniqId.isLocal) - .build() - -fun IrKlibProtoBuf.UniqId.uniqId(): UniqId = UniqId(this.index, this.isLocal) -fun IrKlibProtoBuf.UniqId.uniqIdKey(moduleDescriptor: ModuleDescriptor) = - UniqIdKey(moduleDescriptor, this.uniqId()) - -fun > M.tryGetExtension(extension: GeneratedMessageLite.GeneratedExtension) - = if (this.hasExtension(extension)) this.getExtension(extension) else null - -fun DeclarationDescriptor.getUniqId(): JsKlibMetadataProtoBuf.DescriptorUniqId? = when (this) { - is DeserializedClassDescriptor -> this.classProto.tryGetExtension(JsKlibMetadataProtoBuf.classUniqId) - is DeserializedSimpleFunctionDescriptor -> this.proto.tryGetExtension(JsKlibMetadataProtoBuf.functionUniqId) - is DeserializedPropertyDescriptor -> this.proto.tryGetExtension(JsKlibMetadataProtoBuf.propertyUniqId) - is DeserializedClassConstructorDescriptor -> this.proto.tryGetExtension(JsKlibMetadataProtoBuf.constructorUniqId) - else -> null -} - -fun newDescriptorUniqId(index: Long): JsKlibMetadataProtoBuf.DescriptorUniqId = - JsKlibMetadataProtoBuf.DescriptorUniqId.newBuilder().setIndex(index).build() - -val UniqId.declarationFileName: String get() = "$index${if (isLocal) "L" else "G"}.kjd" \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqSymbolName.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqSymbolName.kt deleted file mode 100644 index b8100ee3626..00000000000 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqSymbolName.kt +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license - * that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir - -import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name - -// This is a little extension over what's used in real mangling -// since some declarations never appear in the bitcode symbols. - -internal fun IrDeclaration.uniqSymbolName(): String = when (this) { - is IrFunction - -> this.uniqFunctionName - is IrProperty - -> this.symbolName - is IrClass - -> this.typeInfoSymbolName - is IrField - -> this.symbolName - is IrEnumEntry - -> this.symbolName - else -> error("Unexpected exported declaration: $this") -} - -private val IrDeclarationParent.fqNameUnique: FqName - get() = when(this) { - is IrPackageFragment -> this.fqName - is IrDeclaration -> this.parent.fqNameUnique.child(this.uniqName) - else -> error(this) - } - -private val IrDeclaration.uniqName: Name - get() = when (this) { - is IrSimpleFunction -> Name.special("<${this.uniqFunctionName}>") - else -> this.name - } - -private val IrProperty.symbolName: String - get() { - val extensionReceiver: String = getter!!.extensionReceiverParameter ?. extensionReceiverNamePart ?: "" - - val containingDeclarationPart = parent.fqNameSafe.let { - if (it.isRoot) "" else "$it." - } - return "kprop:$containingDeclarationPart$extensionReceiver$name" - } - -private val IrEnumEntry.symbolName: String - get() { - val containingDeclarationPart = parent.fqNameSafe.let { - if (it.isRoot) "" else "$it." - } - return "kenumentry:$containingDeclarationPart$name" - } - -// This is basicly the same as .symbolName, but disambiguates external functions with the same C name. -// In addition functions appearing in fq sequence appear as . -private val IrFunction.uniqFunctionName: String - get() { - val parent = this.parent - - val containingDeclarationPart = parent.fqNameUnique.let { - if (it.isRoot) "" else "$it." - } - - return "kfun:$containingDeclarationPart#$functionName" - } diff --git a/generators/tests/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBuf.kt b/generators/tests/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBuf.kt index c9dcb940d13..7b5557f5319 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBuf.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBuf.kt @@ -58,8 +58,9 @@ val PROTO_PATHS: List = listOf( ProtoPath("core/metadata.jvm/src/jvm_metadata.proto"), ProtoPath("core/metadata.jvm/src/jvm_module.proto"), ProtoPath("build-common/src/java_descriptors.proto"), - ProtoPath("compiler/ir/backend.js/src/ir.proto", false), - ProtoPath("compiler/ir/backend.js/src/js.proto", false) + //ProtoPath("compiler/ir/backend.js/src/ir.proto", false), + ProtoPath("compiler/ir/backend.js/src/js.proto", false), + ProtoPath("compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.proto", false) ) private val EXT_OPTIONS_PROTO_PATH = ProtoPath("core/metadata/src/ext_options.proto")