From 3a444cd0f323990c297a5fa4cef8ed1812e03eaf Mon Sep 17 00:00:00 2001 From: Roman Artemev Date: Tue, 29 Jan 2019 18:18:00 +0300 Subject: [PATCH] [JS IR BE] Move IrSerializer from native to JS * Fix issues --- .../common/descriptors/WrappedDescriptors.kt | 2 +- .../kotlin/backend/common/ir/IrUtils.kt | 3 + .../kotlin/backend/common/lower/LowerUtils.kt | 5 +- .../kotlin/ir/backend/js/compiler.kt | 162 +- .../js/lower/BlockDecomposerLowering.kt | 19 +- .../lower/coroutines/StateMachineBuilder.kt | 7 +- .../js/lower/inline/FunctionInlining.kt | 4 +- .../js/lower/inline/LegacyDescriptorUtils.kt | 13 + .../serialization/ir/AdditionalIrUtils.kt | 202 + .../lower/serialization/ir/AnotherIrUtils.kt | 169 + .../lower/serialization/ir/BinaryInterface.kt | 252 + .../serialization/ir/DeclarationTable.kt | 91 + .../lower/serialization/ir/DescriptorUtils.kt | 206 + .../ir/DeserializeDescriptorReference.kt | 94 + .../serialization/ir/IrKlibProtoBuf.java | 57304 ++++++++++++++++ .../ir/IrKlibProtoBufModuleDeserializer.kt | 337 + .../serialization/ir/IrModuleDeserializer.kt | 1131 + .../serialization/ir/IrModuleSerializer.kt | 1153 + .../serialization/ir/IrSerializationUtil.kt | 40 + .../lower/serialization/ir/KLibraryUtils.kt | 12 + .../serialization/ir/KonanStringTable.kt | 53 + .../serialization/ir/LegacyDescriptorUtils.kt | 55 + .../ir/SerializeDescriptorReference.kt | 108 + .../lower/serialization/ir/StringTableUtil.kt | 35 + .../js/lower/serialization/ir/UniqId.kt | 57 + .../lower/serialization/ir/UniqSymbolName.kt | 71 + .../js/lower/serialization/ir/ir.proto | 606 + .../JsKlibMetadataFragmentProvider.kt | 2 +- .../IrElementToJsStatementTransformer.kt | 3 +- .../transformers/irToJs/JsClassGenerator.kt | 6 +- .../js/transformers/irToJs/jsAstUtils.kt | 3 +- .../kotlin/ir/backend/js/utils/Namer.kt | 2 + .../lazy/IrLazyDeclarationBase.kt | 1 + .../kotlin/ir/descriptors/IrBuiltIns.kt | 99 +- .../org/jetbrains/kotlin/ir/types/irTypes.kt | 5 + .../ir/util/DeclarationStubGenerator.kt | 5 + .../generators/protobuf/GenerateProtoBuf.kt | 3 +- .../generators/tests/GenerateIrRuntime.kt | 9 +- 38 files changed, 62204 insertions(+), 125 deletions(-) create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AdditionalIrUtils.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AnotherIrUtils.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/BinaryInterface.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeclarationTable.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DescriptorUtils.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeserializeDescriptorReference.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBuf.java create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBufModuleDeserializer.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleDeserializer.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleSerializer.kt create 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/KLibraryUtils.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KonanStringTable.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/LegacyDescriptorUtils.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/SerializeDescriptorReference.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/StringTableUtil.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqId.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqSymbolName.kt create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/ir.proto diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt index 7bf2fc19363..6897395b09c 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt @@ -583,7 +583,7 @@ open class WrappedClassDescriptor( private val _typeConstructor: TypeConstructor by lazy { LazyTypeConstructor( this, - { emptyList() }, + { declaredTypeParameters }, { owner.superTypes.map { it.toKotlinType() } }, LockBasedStorageManager.NO_LOCKS ) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt index 0974cc6fe68..571ee73e41a 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt @@ -36,6 +36,7 @@ import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.expressions.IrFunctionReference +import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl import org.jetbrains.kotlin.ir.expressions.impl.IrDelegatingConstructorCallImpl import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl @@ -386,6 +387,8 @@ fun IrClass.createImplicitParameterDeclarationWithWrappedDescriptor() { assert(descriptor.declaredTypeParameters.isEmpty()) } +fun isElseBranch(branch: IrBranch) = branch is IrElseBranch || ((branch.condition as? IrConst)?.value == true) + fun IrSimpleFunction.isMethodOfAny() = ((valueParameters.size == 0 && name.asString().let { it == "hashCode" || it == "toString" }) || (valueParameters.size == 1 && name.asString() == "equals" && valueParameters[0].type.isNullableAny())) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt index 9b39a0055f5..653eef09a02 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt @@ -34,6 +34,7 @@ import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.classifierOrFail +import org.jetbrains.kotlin.ir.types.isAny import org.jetbrains.kotlin.ir.util.defaultType import org.jetbrains.kotlin.ir.visitors.IrElementTransformer import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid @@ -209,7 +210,9 @@ fun IrConstructor.callsSuper(irBuiltIns: IrBuiltIns): Boolean { assert(++numberOfCalls == 1) { "More than one delegating constructor call: ${symbol.owner}" } val delegatingClass = expression.symbol.owner.parent as IrClass // TODO: figure out why Lazy IR multiplies Declarations for descriptors and fix it - if (delegatingClass.descriptor == superClass.classifierOrFail.descriptor) + if (delegatingClass.descriptor == superClass.classifierOrFail.descriptor || ( + delegatingClass.defaultType.isAny() && superClass.isAny() + )) callsSuper = true else if (delegatingClass.descriptor != constructedClass.descriptor) throw AssertionError( 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 c55074d7666..ba14c2d13c2 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 @@ -6,42 +6,42 @@ package org.jetbrains.kotlin.ir.backend.js import com.intellij.openapi.project.Project -import com.intellij.openapi.util.io.FileUtil -import com.intellij.openapi.vfs.VfsUtilCore import org.jetbrains.kotlin.backend.common.CompilerPhaseManager -import org.jetbrains.kotlin.backend.common.output.OutputFile -import org.jetbrains.kotlin.backend.common.output.OutputFileCollection -import org.jetbrains.kotlin.backend.common.output.SimpleOutputBinaryFile -import org.jetbrains.kotlin.backend.common.output.SimpleOutputFileCollection +import org.jetbrains.kotlin.backend.common.LoggingContext +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.builtins.functions.functionInterfacePackageFragmentProvider import org.jetbrains.kotlin.config.CommonConfigurationKeys import org.jetbrains.kotlin.backend.common.phaser.invokeToplevel import org.jetbrains.kotlin.config.CommonConfigurationKeys import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.languageVersionSettings +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +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.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.metadata.* import org.jetbrains.kotlin.ir.backend.js.lower.coroutines.CoroutineIntrinsicLowering import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformer import org.jetbrains.kotlin.ir.declarations.IrModuleFragment +import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns +import org.jetbrains.kotlin.ir.util.ConstantValueGenerator import org.jetbrains.kotlin.ir.util.SymbolTable +import org.jetbrains.kotlin.ir.util.TypeTranslator import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS -import org.jetbrains.kotlin.js.resolve.JsPlatform import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator -import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration -import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol import org.jetbrains.kotlin.storage.LockBasedStorageManager -import org.jetbrains.kotlin.utils.JsMetadataVersion -import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils import java.io.File import org.jetbrains.kotlin.utils.DFS +data class Result(val moduleDescriptor: ModuleDescriptor, val generatedCode: String, val moduleFragment: IrModuleFragment?) enum class ModuleType { TEST_RUNTIME, SECONDARY, @@ -59,13 +59,6 @@ class CompiledModule( get() = moduleFragment!!.descriptor as ModuleDescriptorImpl } -fun OutputFileCollection.writeAll(outputDir: File) { - for (file in asList()) { - val output = File(outputDir, file.relativePath) - FileUtil.writeToFile(output, file.asByteArray()) - } -} - fun compile( project: Project, files: List, @@ -92,7 +85,7 @@ fun compile( TopDownAnalyzerFacadeForJS.checkForErrors(files, analysisResult.bindingContext) val symbolTable = SymbolTable() - dependencies.forEach { symbolTable.loadModule(it.moduleFragment!!) } +// irDependencyModules.forEach { symbolTable.loadModule(it) } val psi2IrTranslator = Psi2IrTranslator(configuration.languageVersionSettings) val psi2IrContext = psi2IrTranslator.createGeneratorContext(analysisResult.moduleDescriptor, analysisResult.bindingContext, symbolTable) @@ -111,82 +104,103 @@ fun compile( if (isKlibCompilation) { -// val declarationTable = DeclarationTable(moduleFragment.irBuiltins, DescriptorTable()) -// val serializedIr = IrModuleSerializer(context, declarationTable/*, onlyForInlines = false*/).serializedIrModule(moduleFragment) -// val serializer = KonanSerializationUtil(context, configuration.get(CommonConfigurationKeys.METADATA_VERSION)!!, declarationTable) -// val serializedData = serializer.serializeModule(analysisResult.moduleDescriptor, serializedIr) -// buildLibrary(serializedData) -// + val logggg = object : LoggingContext { + override fun log(message: () -> String) {} + } -// val declarationTable = DeclarationTable(moduleFragment.irBuiltins, DescriptorTable()) -// val serializedIr = IrModuleSerializer(context, declarationTable/*, onlyForInlines = false*/).serializedIrModule(moduleFragment) + val declarationTable = DeclarationTable(moduleFragment.irBuiltins, DescriptorTable(), psi2IrContext.symbolTable) + + val serializedIr = IrModuleSerializer(logggg, declarationTable/*, onlyForInlines = false*/).serializedIrModule(moduleFragment) val serializer = JsKlibMetadataSerializationUtil -// val serializedData = serializer.serializeModule(analysisResult.moduleDescriptor, serializedIr) + val moduleName = configuration.get(CommonConfigurationKeys.MODULE_NAME) as String val metadataVersion = configuration.get(CommonConfigurationKeys.METADATA_VERSION) as? JsKlibMetadataVersion ?: JsKlibMetadataVersion.INSTANCE val moduleDescription = JsKlibMetadataModuleDescriptor(moduleName, dependencies.map { it.name.asString() }, moduleFragment.descriptor) - var index = 0L val serializedData = serializer.serializeMetadata( psi2IrContext.bindingContext, moduleDescription, configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS)!!, metadataVersion - ) { -// val index = declarationTable.descriptorTable.get(it) -// index?.let { newDescriptorUniqId(it) } - JsKlibMetadataProtoBuf.DescriptorUniqId.newBuilder().setIndex(index++).build() - + ) { declarationDescriptor -> + val index = declarationTable.descriptorTable.get(declarationDescriptor) + index?.let { newDescriptorUniqId(it) } } -// buildLibrary(serializedData) -// val stdKlibDir = File("js/js.translator/testData/out/klibs/runtime/").also { it.deleteRecursively() it.mkdirs() } -// -// val moduleFile = File(stdKlibDir, "module.kji") -// moduleFile.writeBytes(serializedIr.module) -// -// for ((id, data) in serializedIr.declarations) { -// val file = File(stdKlibDir, "${id.index}${if (id.isLocal) "L" else "G"}.kjd") -// file.writeBytes(data) -// } -// -// -// val debugFile = File(stdKlibDir, "debug.txt") -// -// for ((id, data) in serializedIr.debugIndex) { -// debugFile.appendText(id.toString()) -// debugFile.appendText(" --- ") -// debugFile.appendText(data) -// debugFile.appendText("\n") -// } - val metadata = File(stdKlibDir, "${moduleDescription.name}${JsKlibMetadataSerializationUtil.CLASS_METADATA_FILE_EXTENSION}").also { + val moduleFile = File(stdKlibDir, "module.kji") + moduleFile.writeBytes(serializedIr.module) + + val irDeclarationDir = File(stdKlibDir, "ir/").also { it.mkdir() } + + for ((id, data) in serializedIr.declarations) { + val file = File(irDeclarationDir, id.declarationFileName) + file.writeBytes(data) + } + + + val debugFile = File(stdKlibDir, "debug.txt") + + for ((id, data) in serializedIr.debugIndex) { + debugFile.appendText(id.toString()) + debugFile.appendText(" --- ") + debugFile.appendText(data) + debugFile.appendText("\n") + } + + val metadata = File(stdKlibDir, "${moduleDescription.name}.${JsKlibMetadataSerializationUtil.CLASS_METADATA_FILE_EXTENSION}").also { it.writeBytes(serializedData.asByteArray()) } val storageManager = LockBasedStorageManager("JsConfig") -// // CREATE NEW MODULE DESCRIPTOR HERE AND DESERIALIZE IT - val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER, LookupTracker.DO_NOTHING) val parts = serializer.readModuleAsProto(metadata.readBytes()) - val md = ModuleDescriptorImpl( - Name.special("<$moduleName>"), storageManager, JsPlatform.builtIns - ) - val provider = createJsKlibMetadataPackageFragmentProvider( - storageManager, md, parts.header, parts.body, metadataVersion, - CompilerDeserializationConfiguration(configuration.languageVersionSettings), - lookupTracker + val builtIns = object : KotlinBuiltIns(storageManager) {}//analysisResult.moduleDescriptor.builtIns + val md = ModuleDescriptorImpl(Name.special("<$moduleName>"), storageManager, builtIns) + builtIns.builtInsModule = md + val packageProviders = listOf( + functionInterfacePackageFragmentProvider(storageManager, md), + createJsKlibMetadataPackageFragmentProvider( + storageManager, md, parts.header, parts.body, metadataVersion, + CompilerDeserializationConfiguration(configuration.languageVersionSettings), + lookupTracker + ) ) - md.initialize(provider) - md.setDependencies(listOf(md, md.builtIns.builtInsModule)) + md.initialize(CompositePackageFragmentProvider(packageProviders)) + md.setDependencies(listOf(md/*, builtIns.builtInsModule*/)) - TODO("Implemenet IrSerialization") + + val st = SymbolTable() + + val typeTranslator = TypeTranslator(st, configuration.languageVersionSettings).also { + it.constantValueGenerator = ConstantValueGenerator(md, st) + } + + val irBuiltIns = IrBuiltIns(md.builtIns, typeTranslator, st) + + val deserializer = IrKlibProtoBufModuleDeserializer( + md, + logggg, + irBuiltIns, + stdKlibDir, + st, + null + ) + val deserializedModuleFragment = deserializer.deserializeIrModule(md, moduleFile.readBytes(), true) + + val context = JsIrBackendContext(md, irBuiltIns, st, deserializedModuleFragment, configuration, irDependencyModules) + + deserializedModuleFragment.replaceUnboundSymbols(context) + + jsPhases.invokeToplevel(context.phaseConfig, context, moduleFragment) + + return Result(md, context.jsProgram.toString(), null) } else { // TODO: Split compilation into two steps: kt -> ir, ir -> js @@ -211,9 +225,17 @@ fun compile( } } - jsPhases.invokeToplevel(context.phaseConfig, context, moduleFragment) + val context = JsIrBackendContext( + analysisResult.moduleDescriptor, + psi2IrContext.irBuiltIns, + psi2IrContext.symbolTable, + moduleFragment, + configuration, + irDependencyModules + ) - val jsProgram = moduleFragment.accept(IrModuleToJsTransformer(context), null) + val jsProgram = moduleFragment.accept(IrModuleToJsTransformer(context), null) - return CompiledModule(moduleName, jsProgram.toString(), context.moduleFragmentCopy, moduleType, dependencies) + return CompiledModule(moduleName, jsProgram.toString(), context.moduleFragmentCopy, moduleType, dependencies) + } } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt index 337857c44a1..1c91bb89bfe 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.ir.backend.js.lower import org.jetbrains.kotlin.backend.common.DeclarationContainerLoweringPass +import org.jetbrains.kotlin.backend.common.ir.isElseBranch import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext @@ -366,8 +367,8 @@ class BlockDecomposerTransformer(private val context: JsIrBackendContext) : IrEl if (compositeCount == 0) { val branches = results.map { (cond, res, orig) -> - when (orig) { - is IrElseBranch -> IrElseBranchImpl(orig.startOffset, orig.endOffset, cond, res) + when { + isElseBranch(orig) -> IrElseBranchImpl(orig.startOffset, orig.endOffset, cond, res) else /* IrBranch */ -> IrBranchImpl(orig.startOffset, orig.endOffset, cond, res) } } @@ -384,7 +385,7 @@ class BlockDecomposerTransformer(private val context: JsIrBackendContext) : IrEl appendBlock.statements += condStatements.run { subList(0, lastIndex) } JsIrBuilder.buildBlock(unitType).also { - val elseBlock = if (orig is IrElseBranch) null else it + val elseBlock = if (isElseBranch(orig)) null else it val ifElseNode = JsIrBuilder.buildIfElse(orig.startOffset, orig.endOffset, unitType, condValue, res, elseBlock, expression.origin) appendBlock.statements += ifElseNode @@ -666,9 +667,9 @@ class BlockDecomposerTransformer(private val context: JsIrBackendContext) : IrEl val newBranches = decomposedResults.map { (branch, condition, result) -> val newResult = wrap(result, irVar) - when (branch) { - is IrElseBranch -> IrElseBranchImpl(branch.startOffset, branch.endOffset, condition, newResult) - else /* IrBranch */ -> IrBranchImpl(branch.startOffset, branch.endOffset, condition, newResult) + when { + isElseBranch(branch) -> IrElseBranchImpl(branch.startOffset, branch.endOffset, condition, newResult) + else /* IrBranch */ -> IrBranchImpl(branch.startOffset, branch.endOffset, condition, newResult) } } @@ -679,9 +680,9 @@ class BlockDecomposerTransformer(private val context: JsIrBackendContext) : IrEl return JsIrBuilder.buildComposite(expression.type, listOf(irVar, newWhen, JsIrBuilder.buildGetValue(irVar.symbol))) } else { val newBranches = decomposedResults.map { (branch, condition, result) -> - when (branch) { - is IrElseBranch -> IrElseBranchImpl(branch.startOffset, branch.endOffset, condition, result) - else /* IrBranch */ -> IrBranchImpl(branch.startOffset, branch.endOffset, condition, result) + when { + isElseBranch(branch) -> IrElseBranchImpl(branch.startOffset, branch.endOffset, condition, result) + else /* IrBranch */ -> IrBranchImpl(branch.startOffset, branch.endOffset, condition, result) } } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt index 41ac9e4390d..2339423372e 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.ir.backend.js.lower.coroutines +import org.jetbrains.kotlin.backend.common.ir.isElseBranch import org.jetbrains.kotlin.backend.common.ir.isSuspend import org.jetbrains.kotlin.backend.common.peek import org.jetbrains.kotlin.backend.common.pop @@ -351,8 +352,8 @@ class StateMachineBuilder( if (it.result in suspendableNodes) { suspendableNodes += wrapped } - when (it) { - is IrElseBranch -> IrElseBranchImpl(it.startOffset, it.endOffset, it.condition, wrapped) + when { + isElseBranch(it) -> IrElseBranchImpl(it.startOffset, it.endOffset, it.condition, wrapped) else /* IrBranch */ -> IrBranchImpl(it.startOffset, it.endOffset, it.condition, wrapped) } } @@ -365,7 +366,7 @@ class StateMachineBuilder( val rootBlock = currentBlock for (branch in branches) { - if (branch !is IrElseBranch) { + if (!isElseBranch(branch)) { branch.condition.acceptVoid(this) val branchBlock = JsIrBuilder.buildComposite(branch.result.type) val elseBlock = JsIrBuilder.buildComposite(expression.type) 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 96fa2bf9dc3..747785ed133 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 @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl import org.jetbrains.kotlin.ir.expressions.impl.IrReturnableBlockImpl import org.jetbrains.kotlin.ir.expressions.impl.IrVarargImpl import org.jetbrains.kotlin.ir.symbols.impl.IrReturnableBlockSymbolImpl +import org.jetbrains.kotlin.ir.types.irTypeKotlinBuiltIns import org.jetbrains.kotlin.ir.types.toKotlinType import org.jetbrains.kotlin.ir.util.file import org.jetbrains.kotlin.ir.util.getArguments @@ -124,6 +125,7 @@ internal class FunctionInlining(val context: Context): IrElementTransformerWithC //-------------------------------------------------------------------------// fun inline(irModule: IrModuleFragment): IrElement { + irTypeKotlinBuiltIns = irModule.irBuiltins.builtIns val transformedModule = irModule.accept(this, Ref(false)) DescriptorSubstitutorForExternalScope(globalSubstituteMap, context).run(transformedModule) // Transform calls to object that might be returned from inline function call. return transformedModule @@ -371,7 +373,7 @@ private class Inliner(val globalSubstituteMap: MutableMap T.original get() = this +val IrDeclaration.containingDeclaration get() = this.parent + +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 IrField.fqNameSafe: FqName get() = this.parent.fqNameSafe.child(this.name) + +/** + * @return naturally-ordered list of all parameters available inside the function body. + */ +val IrFunction.allParameters: List + get() = if (this is IrConstructor) { + listOf(this.constructedClass.thisReceiver + ?: error(this.descriptor) + ) + explicitParameters + } else { + explicitParameters + } + +val IrValueParameter.isVararg get() = this.varargElementType != null + +val IrFunction.isSuspend get() = this is IrSimpleFunction && this.isSuspend + +fun IrClass.isUnit() = this.fqNameSafe == KotlinBuiltIns.FQ_NAMES.unit.toSafe() + +fun IrClass.isKotlinArray() = this.fqNameSafe == KotlinBuiltIns.FQ_NAMES.array.toSafe() + +val IrClass.superClasses get() = this.superTypes.map { it.classifierOrFail as IrClassSymbol } +fun IrClass.getSuperClassNotAny() = this.superClasses.map { it.owner }.atMostOne { !it.isInterface && !it.isAny() } + +fun IrClass.isAny() = this.fqNameSafe == KotlinBuiltIns.FQ_NAMES.any.toSafe() +fun IrClass.isNothing() = this.fqNameSafe == KotlinBuiltIns.FQ_NAMES.nothing.toSafe() + +fun IrClass.getSuperInterfaces() = this.superClasses.map { it.owner }.filter { it.isInterface } + +val IrProperty.konanBackingField: IrField? + get() { + assert(this.isReal) + this.backingField?.let { return it } + +// (this.descriptor as? DeserializedPropertyDescriptor)?.konanBackingField?.let { backingFieldDescriptor -> +// val result = IrFieldImpl( +// this.startOffset, +// this.endOffset, +// IrDeclarationOrigin.PROPERTY_BACKING_FIELD, +// backingFieldDescriptor, +// this.getter!!.returnType +// ).also { +// it.parent = this.parent +// } +// this.backingField = result +// return result +// } + + return null + } + +val IrField.containingClass get() = this.parent as? IrClass + +val IrFunction.isReal get() = this.origin != IrDeclarationOrigin.FAKE_OVERRIDE + +// Note: psi2ir doesn't set `origin = FAKE_OVERRIDE` for fields and properties yet. +val IrProperty.isReal: Boolean get() = this.descriptor.kind.isReal +val IrField.isReal: Boolean get() = this.descriptor.kind.isReal + +val IrSimpleFunction.isOverridable: Boolean + get() = visibility != Visibilities.PRIVATE + && modality != Modality.FINAL + && (parent as? IrClass)?.isFinalClass != true + +val IrFunction.isOverridable get() = this is IrSimpleFunction && this.isOverridable + +val IrFunction.isOverridableOrOverrides + get() = this is IrSimpleFunction && (this.isOverridable || this.overriddenSymbols.isNotEmpty()) + +val IrClass.isFinalClass: Boolean + get() = modality == Modality.FINAL && kind != ClassKind.ENUM_CLASS + +fun IrSimpleFunction.overrides(other: IrSimpleFunction): Boolean { + if (this == other) return true + + this.overriddenSymbols.forEach { + if (it.owner.overrides(other)) { + return true + } + } + + return false +} + +fun IrClass.isSpecialClassWithNoSupertypes() = this.isAny() || this.isNothing() + +internal val IrValueParameter.isValueParameter get() = this.index >= 0 + +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 IrDeclaration.getAnnotationArgumentValue(fqName: FqName, argumentName: String): T? { + val annotation = this.annotations.findAnnotation(fqName) + if (annotation == null) { + // As a last resort try searching the descriptor. + // This is needed for a period while we don't have IR for platform libraries. + return this.descriptor.annotations + .findAnnotation(fqName) + ?.getArgumentValueOrNull(argumentName) + } + for (index in 0 until annotation.valueArgumentsCount) { + val parameter = annotation.symbol.owner.valueParameters[index] + if (parameter.name == Name.identifier(argumentName)) { + val actual = annotation.getValueArgument(index) as? IrConst + return actual?.value + } + } + return null +} + +fun IrValueParameter.isInlineParameter(): Boolean = + !this.isNoinline && (this.type.isFunction() || this.type.isSuspendFunction()) && !this.type.isMarkedNullable() + +val IrDeclaration.parentDeclarationsWithSelf: Sequence + get() = generateSequence(this, { it.parent as? IrDeclaration }) + +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 \ 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 new file mode 100644 index 00000000000..77c4c8f7506 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/AnotherIrUtils.kt @@ -0,0 +1,169 @@ +/* + * 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.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.IrField +import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction +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 + +@Deprecated("Do not call this method in the compiler front-end.") +internal val IrField.isDelegate + get() = @Suppress("DEPRECATION") this.descriptor.isDelegated + +internal const val SYNTHETIC_OFFSET = -2 + +class NaiveSourceBasedFileEntryImpl(override val name: String) : SourceManager.FileEntry { + + private val lineStartOffsets: IntArray + + //-------------------------------------------------------------------------// + + init { + val file = File(name) + if (file.isFile) { + // 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 + file.forEachLine { line -> + buffer.add(currentOffset) + currentOffset += line.length + separatorLength + } + buffer.add(currentOffset) + lineStartOffsets = buffer.toIntArray() + } else { + lineStartOffsets = IntArray(0) + } + } + + //-------------------------------------------------------------------------// + + 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") + +private val functionalPackages = + listOf(kotlinFqn, kotlinFqn.child(Name.identifier("coroutines")), kotlinFqn.child(Name.identifier("reflect"))) + +internal val BUILT_IN_FUNCTION_CLASS_COUNT = 4 +internal val BUILT_IN_FUNCTION_ARITY_COUNT = 256 +internal val BUILT_IN_UNIQ_ID_GAP = 2 * BUILT_IN_FUNCTION_ARITY_COUNT * BUILT_IN_FUNCTION_CLASS_COUNT +internal val BUILT_IN_UNIQ_ID_CLASS_OFFSET = BUILT_IN_FUNCTION_CLASS_COUNT * BUILT_IN_FUNCTION_ARITY_COUNT + +internal fun isBuiltInFunction(value: IrDeclaration): Boolean = when (value) { + is IrSimpleFunction -> value.name.asString() == "invoke" && (value.parent as? IrClass)?.let { isBuiltInFunction(it) } == true + is IrClass -> { + val fqn = value.parent.fqNameSafe + functionalPackages.any { it == fqn } && value.name.asString().let { functionPattern.matcher(it).find() } + } + else -> false +} + + +private fun builtInOffset(function: IrSimpleFunction): Long { + val isK = function.parentAsClass.name.asString().startsWith("K") + return when { + isK && function.isSuspend -> 3 + isK -> 2 + function.isSuspend -> 1 + else -> 0 + } +} + +internal fun builtInFunctionId(value: IrDeclaration): Long = when (value) { + is IrSimpleFunction -> { + value.run { valueParameters.size + builtInOffset(value) * BUILT_IN_FUNCTION_ARITY_COUNT }.toLong() + } + is IrClass -> { + BUILT_IN_UNIQ_ID_CLASS_OFFSET + builtInFunctionId(value.declarations.first { it.name.asString() == "invoke" }) + } + else -> error("Only class or function is expected") +} + + +internal fun isBuiltInFunction(value: DeclarationDescriptor): Boolean = when (value) { + is FunctionInvokeDescriptor -> isBuiltInFunction(value.containingDeclaration) + is ClassDescriptor -> { + val fqn = (value.containingDeclaration as? PackageFragmentDescriptor)?.fqName + functionalPackages.any { it == fqn } && value.name.asString().let { functionPattern.matcher(it).find() } + } + else -> false +} + +private fun builtInOffset(function: FunctionInvokeDescriptor): Long { + val isK = function.containingDeclaration.name.asString().startsWith("K") + return when { + isK && function.isSuspend -> 3 + isK -> 2 + function.isSuspend -> 1 + else -> 0 + } +} + +internal fun builtInFunctionId(value: DeclarationDescriptor): Long = when (value) { + is FunctionInvokeDescriptor -> { + value.run { valueParameters.size + builtInOffset(value) * BUILT_IN_FUNCTION_ARITY_COUNT }.toLong() + } + is ClassDescriptor -> { + 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 new file mode 100644 index 00000000000..275f99802d2 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/BinaryInterface.kt @@ -0,0 +1,252 @@ +/* + * 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 IrFunction.symbolName: String + get() { + if (!this.isExported()) { + throw AssertionError(this.descriptor.toString()) + } + + if (isExternal) { + this.descriptor.externalSymbolOrThrow()?.let { + return it + } + } + +// this.descriptor.annotations.findAnnotation(exportForCppRuntimeAnnotation)?.let { +// val name = getAnnotationValue(it) ?: this.name.asString() +// return name // no wrapping currently required +// } + + val parent = this.parent + + val containingDeclarationPart = parent.fqNameSafe.let { + if (it.isRoot) "" else "$it." + } + return "kfun:$containingDeclarationPart$functionName" + } + +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/DeclarationTable.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeclarationTable.kt new file mode 100644 index 00000000000..95d77784785 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeclarationTable.kt @@ -0,0 +1,91 @@ +/* + * 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.descriptors.getFunction +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.incremental.components.NoLookupLocation +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 +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.jvm.modules.KOTLIN_STDLIB_MODULE_NAME +import java.util.regex.Pattern + +fun MutableMap.putOnce(k:K, v: V): Unit { + assert(!this.containsKey(k) || this[k] == v) { + "adding $v for $k, but it is already ${this[k]} for $k" + } + this.put(k, v) +} + +class DescriptorTable { + private val descriptors = mutableMapOf() + fun put(descriptor: DeclarationDescriptor, uniqId: UniqId) { + descriptors.putOnce(descriptor, uniqId.index) + } + fun get(descriptor: DeclarationDescriptor) = descriptors[descriptor] +} + +// TODO: We don't manage id clashes anyhow now. +class DeclarationTable(val builtIns: IrBuiltIns, val descriptorTable: DescriptorTable, val symbolTable: SymbolTable) { + + private val table = mutableMapOf() + val debugIndex = mutableMapOf() + val descriptors = descriptorTable + private var currentIndex = 0x1_0000_0000L + + private val FUNCTION_INDEX_START: Long + + init { + val known = builtIns.knownBuiltins + known.forEach { + table.put(it, UniqId(currentIndex++, false)) + } + + FUNCTION_INDEX_START = currentIndex + currentIndex += BUILT_IN_UNIQ_ID_GAP + } + + fun uniqIdByDeclaration(value: IrDeclaration): UniqId { + val index = table.getOrPut(value) { + + if (isBuiltInFunction(value)) { + UniqId(FUNCTION_INDEX_START + builtInFunctionId(value), false) + } else if (value.origin == IrDeclarationOrigin.FAKE_OVERRIDE || + !value.isExported() + || value is IrVariable + || value is IrTypeParameter + || value is IrValueParameter + || value is IrAnonymousInitializerImpl + ) { + + val desc = value.descriptor + if (desc is CallableDescriptor) { + if (desc.visibility == Visibilities.PUBLIC || value.origin != IrDeclarationOrigin.FAKE_OVERRIDE) { + fun foo(){} + foo() + } + } + UniqId(currentIndex++, true) + } else { + UniqId(value.uniqIdIndex, false) + } + } + + debugIndex.put(index, "${if (index.isLocal) "" else value.uniqSymbolName()} descriptor = ${value.descriptor}") + + return index + } +} + +// This is what we pre-populate tables with +val IrBuiltIns.knownBuiltins + get() = irBuiltInsExternalPackageFragment.declarations \ 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.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DescriptorUtils.kt new file mode 100644 index 00000000000..a1fdee42173 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DescriptorUtils.kt @@ -0,0 +1,206 @@ +/* + * 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.ir.types.isUnit +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe +import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny +import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces +import org.jetbrains.kotlin.types.SimpleType +import org.jetbrains.kotlin.types.typeUtil.isUnit + +/** + * List of all implemented interfaces (including those which implemented by a super class) + */ +internal val IrClass.implementedInterfaces: List + get() { + val superClassImplementedInterfaces = this.getSuperClassNotAny()?.implementedInterfaces ?: emptyList() + val superInterfaces = this.getSuperInterfaces() + val superInterfacesImplementedInterfaces = superInterfaces.flatMap { it.implementedInterfaces } + return (superClassImplementedInterfaces + + superInterfacesImplementedInterfaces + + superInterfaces).distinct() + } + + +/** + * Implementation of given method. + * + * TODO: this method is actually a part of resolve and probably duplicates another one + */ +internal fun IrSimpleFunction.resolveFakeOverride(allowAbstract: Boolean = false): IrSimpleFunction { + if (this.isReal) { + return this + } + + val visited = mutableSetOf() + val realSupers = mutableSetOf() + + fun findRealSupers(function: IrSimpleFunction) { + if (function in visited) return + visited += function + if (function.isReal) { + realSupers += function + } else { + function.overriddenSymbols.forEach { findRealSupers(it.owner) } + } + } + + findRealSupers(this) + + if (realSupers.size > 1) { + visited.clear() + + fun excludeOverridden(function: IrSimpleFunction) { + if (function in visited) return + visited += function + function.overriddenSymbols.forEach { + realSupers.remove(it.owner) + excludeOverridden(it.owner) + } + } + + realSupers.toList().forEach { excludeOverridden(it) } + } + + return realSupers.first { allowAbstract || it.modality != Modality.ABSTRACT } +} + +// TODO: don't forget to remove descriptor access here. +//internal val FunctionDescriptor.isTypedIntrinsic: Boolean +// get() = this.descriptor.isTypedIntrinsic +// +//internal val DeclarationDescriptor.isFrozen: Boolean +// get() = this.descriptor.isFrozen + +internal val arrayTypes = setOf( + "kotlin.Array", + "kotlin.ByteArray", + "kotlin.CharArray", + "kotlin.ShortArray", + "kotlin.IntArray", + "kotlin.LongArray", + "kotlin.FloatArray", + "kotlin.DoubleArray", + "kotlin.BooleanArray", + "kotlin.native.ImmutableBlob", + "kotlin.native.internal.NativePtrArray" +) + + +internal val IrClass.isArray: Boolean + get() = this.fqNameSafe.asString() in arrayTypes + + +internal val IrClass.isInterface: Boolean + get() = (this.kind == ClassKind.INTERFACE) + +fun IrClass.isAbstract() = this.modality == Modality.SEALED || this.modality == Modality.ABSTRACT + || this.kind == ClassKind.ENUM_CLASS + +//internal fun FunctionDescriptor.hasValueTypeAt(index: Int): Boolean { +// when (index) { +// 0 -> return !isSuspend && returnType.let { (it.isInlined() || it.isUnit()) } +// 1 -> return dispatchReceiverParameter.let { it != null && it.type.isInlined() } +// 2 -> return extensionReceiverParameter.let { it != null && it.type.isInlined() } +// else -> return this.valueParameters[index - 3].type.isInlined() +// } +//} +// +//internal fun FunctionDescriptor.hasReferenceAt(index: Int): Boolean { +// when (index) { +// 0 -> return isSuspend || returnType.let { !it.isInlined() && !it.isUnit() } +// 1 -> return dispatchReceiverParameter.let { it != null && !it.type.isInlined() } +// 2 -> return extensionReceiverParameter.let { it != null && !it.type.isInlined() } +// else -> return !this.valueParameters[index - 3].type.isInlined() +// } +//} + +//private fun FunctionDescriptor.needBridgeToAt(target: FunctionDescriptor, index: Int) +// = hasValueTypeAt(index) xor target.hasValueTypeAt(index) + +//internal fun FunctionDescriptor.needBridgeTo(target: FunctionDescriptor) +// = (0..this.valueParameters.size + 2).any { needBridgeToAt(target, it) } + +internal val IrSimpleFunction.target: IrSimpleFunction + get() = (if (modality == Modality.ABSTRACT) this else resolveFakeOverride()).original + +internal val IrFunction.target: IrFunction get() = when (this) { + is IrSimpleFunction -> this.target + is IrConstructor -> this + else -> error(this) +} + +//private fun FunctionDescriptor.bridgeDirectionToAt(target: FunctionDescriptor, index: Int) +// = when { +// hasValueTypeAt(index) && target.hasReferenceAt(index) -> BridgeDirection.FROM_VALUE_TYPE +// hasReferenceAt(index) && target.hasValueTypeAt(index) -> BridgeDirection.TO_VALUE_TYPE +// else -> BridgeDirection.NOT_NEEDED +//} + +val IrSimpleFunction.allOverriddenDescriptors: Set + get() { + val result = mutableSetOf() + + fun traverse(function: IrSimpleFunction) { + if (function in result) return + result += function + function.overriddenSymbols.forEach { traverse(it.owner) } + } + + traverse(this) + + return result + } + +//internal fun IrSimpleFunction.bridgeDirectionsTo( +// overriddenDescriptor: IrSimpleFunction +//): BridgeDirections { +// val ourDirections = BridgeDirections(this.valueParameters.size) +// for (index in ourDirections.array.indices) +// ourDirections.array[index] = this.bridgeDirectionToAt(overriddenDescriptor, index) +// +// val target = this.target +// if (!this.isReal && modality != Modality.ABSTRACT +// && target.overrides(overriddenDescriptor) +// && ourDirections == target.bridgeDirectionsTo(overriddenDescriptor)) { +// // Bridge is inherited from superclass. +// return BridgeDirections(this.valueParameters.size) +// } +// +// return ourDirections +//} + +tailrec internal fun IrDeclaration.findPackage(): IrPackageFragment { + val parent = this.parent + return parent as? IrPackageFragment + ?: (parent as IrDeclaration).findPackage() +} + +fun IrFunction.isComparisonDescriptor(map: Map): Boolean = + this in map.values + +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/DeserializeDescriptorReference.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeserializeDescriptorReference.kt new file mode 100644 index 00000000000..ae9ec512c95 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/DeserializeDescriptorReference.kt @@ -0,0 +1,94 @@ +/* + * 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.incremental.components.NoLookupLocation +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe +import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor + +class DescriptorReferenceDeserializer(val currentModule: ModuleDescriptor, val resolvedForwardDeclarations: MutableMap) { + + fun deserializeDescriptorReference( + proto: IrKlibProtoBuf.DescriptorReference, + checkerDesc: (DeclarationDescriptor) -> Long?, + checkerID: (Long) -> Boolean, + descriptorResolver: (FqName) -> DeclarationDescriptor + ): DeclarationDescriptor { + val packageFqName = + if (proto.packageFqName == "") FqName.ROOT else FqName(proto.packageFqName) // TODO: whould we store an empty string in the protobuf? + val classFqName = FqName(proto.classFqName) + val protoIndex = if (proto.hasUniqId()) proto.uniqId.index else null + + val (clazz, members) = if (proto.classFqName == "") { + Pair(null, currentModule.getPackage(packageFqName).memberScope.getContributedDescriptors()) + } else { + val clazz = currentModule.findClassAcrossModuleDependencies(ClassId(packageFqName, classFqName, false))!! + Pair(clazz, clazz.unsubstitutedMemberScope.getContributedDescriptors() + clazz.getConstructors()) + } + + if (proto.packageFqName.startsWith("cnames.") || proto.packageFqName.startsWith("objcnames.")) { + val descriptor = + currentModule.findClassAcrossModuleDependencies(ClassId(packageFqName, FqName(proto.name), false))!! + if (!descriptor.fqNameUnsafe.asString().startsWith("cnames") && !descriptor.fqNameUnsafe.asString().startsWith( + "objcnames" + ) + ) { + if (descriptor is DeserializedClassDescriptor) { + val uniqId = UniqId(descriptor.getUniqId()!!.index, false) + val newKey = UniqIdKey(null, uniqId) + val oldKey = UniqIdKey(null, UniqId(protoIndex!!, false)) + + resolvedForwardDeclarations.put(oldKey, newKey) + } else { + /* ??? */ + } + } + return descriptor + } + + if (proto.isEnumEntry) { + val name = proto.name + val memberScope = (clazz as DeserializedClassDescriptor).getUnsubstitutedMemberScope() + return memberScope.getContributedClassifier(Name.identifier(name), NoLookupLocation.FROM_BACKEND)!! + } + + if (proto.isEnumSpecial) { + val name = proto.name + return clazz!!.getStaticScope() + .getContributedFunctions(Name.identifier(name), NoLookupLocation.FROM_BACKEND).single() + } + + if (protoIndex?.let { checkerID(it) } == true) { + return descriptorResolver(packageFqName.child(Name.identifier(proto.name))) + } + + members.forEach { member -> + if (proto.isDefaultConstructor && member is ClassConstructorDescriptor) return member + + val realMembers = + if (proto.isFakeOverride && member is CallableMemberDescriptor && member.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) + member.resolveFakeOverrideMaybeAbstract().map { it.original } + else + setOf(member) + + val memberIndices = realMembers.map { it.getUniqId()?.index ?: checkerDesc(it) }.filterNotNull() + + if (memberIndices.contains(protoIndex)) { + return when { + member is PropertyDescriptor && proto.isSetter -> member.setter!! + member is PropertyDescriptor && proto.isGetter -> member.getter!! + else -> member + } + } + } + + error("Could not find serialized descriptor for index: ${proto.uniqId.index} ${proto.packageFqName},${proto.classFqName},${proto.name}") + } +} \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBuf.java b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBuf.java new file mode 100644 index 00000000000..8f5494c68e9 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBuf.java @@ -0,0 +1,57304 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/ir.proto + +package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir; + +public final class IrKlibProtoBuf { + private IrKlibProtoBuf() {} + public static void registerAllExtensions( + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite registry) { + } + /** + * Protobuf enum {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrSymbolKind) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrTypeVariance) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrTypeOperator) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.ClassKind) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.ModalityKind) + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrSyntheticBodyKind) + } + + public interface DescriptorReferenceOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required string package_fq_name = 1; + */ + boolean hasPackageFqName(); + /** + * required string package_fq_name = 1; + */ + java.lang.String getPackageFqName(); + /** + * required string package_fq_name = 1; + */ + org.jetbrains.kotlin.protobuf.ByteString + getPackageFqNameBytes(); + + /** + * required string class_fq_name = 2; + */ + boolean hasClassFqName(); + /** + * required string class_fq_name = 2; + */ + java.lang.String getClassFqName(); + /** + * required string class_fq_name = 2; + */ + org.jetbrains.kotlin.protobuf.ByteString + getClassFqNameBytes(); + + /** + * required string name = 3; + */ + boolean hasName(); + /** + * required string name = 3; + */ + java.lang.String getName(); + /** + * required string name = 3; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + boolean hasUniqId(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.DescriptorReference} + */ + public static final class DescriptorReference extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + packageFqName_ = bs; + break; + } + case 18: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + classFqName_ = bs; + break; + } + case 26: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000004; + name_ = bs; + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = uniqId_.toBuilder(); + } + uniqId_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 java.lang.Object packageFqName_; + /** + * required string package_fq_name = 1; + */ + public boolean hasPackageFqName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string package_fq_name = 1; + */ + public java.lang.String getPackageFqName() { + java.lang.Object ref = packageFqName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + packageFqName_ = s; + } + return s; + } + } + /** + * required string package_fq_name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getPackageFqNameBytes() { + java.lang.Object ref = packageFqName_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + packageFqName_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int CLASS_FQ_NAME_FIELD_NUMBER = 2; + private java.lang.Object classFqName_; + /** + * required string class_fq_name = 2; + */ + public boolean hasClassFqName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string class_fq_name = 2; + */ + public java.lang.String getClassFqName() { + java.lang.Object ref = classFqName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + classFqName_ = s; + } + return s; + } + } + /** + * required string class_fq_name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getClassFqNameBytes() { + java.lang.Object ref = classFqName_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + classFqName_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int NAME_FIELD_NUMBER = 3; + private java.lang.Object name_; + /** + * required string name = 3; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string name = 3; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 3; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int UNIQ_ID_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId uniqId_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + public boolean hasUniqId() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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_ = ""; + classFqName_ = ""; + name_ = ""; + uniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 (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.writeBytes(1, getPackageFqNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getClassFqNameBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBytes(3, getNameBytes()); + } + 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 + .computeBytesSize(1, getPackageFqNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBytesSize(2, getClassFqNameBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBytesSize(3, getNameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReferenceOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + packageFqName_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + classFqName_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + uniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance()) return this; + if (other.hasPackageFqName()) { + bitField0_ |= 0x00000001; + packageFqName_ = other.packageFqName_; + + } + if (other.hasClassFqName()) { + bitField0_ |= 0x00000002; + classFqName_ = other.classFqName_; + + } + if (other.hasName()) { + bitField0_ |= 0x00000004; + name_ = other.name_; + + } + 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 (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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object packageFqName_ = ""; + /** + * required string package_fq_name = 1; + */ + public boolean hasPackageFqName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string package_fq_name = 1; + */ + public java.lang.String getPackageFqName() { + java.lang.Object ref = packageFqName_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + packageFqName_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string package_fq_name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getPackageFqNameBytes() { + java.lang.Object ref = packageFqName_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + packageFqName_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string package_fq_name = 1; + */ + public Builder setPackageFqName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + packageFqName_ = value; + + return this; + } + /** + * required string package_fq_name = 1; + */ + public Builder clearPackageFqName() { + bitField0_ = (bitField0_ & ~0x00000001); + packageFqName_ = getDefaultInstance().getPackageFqName(); + + return this; + } + /** + * required string package_fq_name = 1; + */ + public Builder setPackageFqNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + packageFqName_ = value; + + return this; + } + + private java.lang.Object classFqName_ = ""; + /** + * required string class_fq_name = 2; + */ + public boolean hasClassFqName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string class_fq_name = 2; + */ + public java.lang.String getClassFqName() { + java.lang.Object ref = classFqName_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + classFqName_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string class_fq_name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getClassFqNameBytes() { + java.lang.Object ref = classFqName_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + classFqName_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string class_fq_name = 2; + */ + public Builder setClassFqName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + classFqName_ = value; + + return this; + } + /** + * required string class_fq_name = 2; + */ + public Builder clearClassFqName() { + bitField0_ = (bitField0_ & ~0x00000002); + classFqName_ = getDefaultInstance().getClassFqName(); + + return this; + } + /** + * required string class_fq_name = 2; + */ + public Builder setClassFqNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + classFqName_ = value; + + return this; + } + + private java.lang.Object name_ = ""; + /** + * required string name = 3; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string name = 3; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 3; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 3; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + name_ = value; + + return this; + } + /** + * required string name = 3; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000004); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 3; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + name_ = value; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId uniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + public boolean hasUniqId() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getUniqId() { + return uniqId_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + public Builder setUniqId(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + uniqId_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + public Builder setUniqId( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.Builder builderForValue) { + uniqId_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + public Builder mergeUniqId(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + uniqId_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance()) { + uniqId_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.newBuilder(uniqId_).mergeFrom(value).buildPartial(); + } else { + uniqId_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 4; + */ + public Builder clearUniqId() { + uniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.DescriptorReference) + } + + static { + defaultInstance = new DescriptorReference(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference) + } + + public interface UniqIdOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.UniqId} + */ + public static final class UniqId extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqIdOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.UniqId) + } + + static { + defaultInstance = new UniqId(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId) + } + + public interface CoordinatesOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.Coordinates} + */ + public static final class Coordinates extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.CoordinatesOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.Coordinates) + } + + static { + defaultInstance = new Coordinates(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates) + } + + public interface IrDeclarationContainerOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + java.util.List + getDeclarationList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDeclaration(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + int getDeclarationCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer} + */ + public static final class IrDeclarationContainer extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + declaration_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + declaration_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public java.util.List getDeclarationList() { + return declaration_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public java.util.List + getDeclarationOrBuilderList() { + return declaration_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public int getDeclarationCount() { + return declaration_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDeclaration(int index) { + return declaration_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainerOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public java.util.List getDeclarationList() { + return java.util.Collections.unmodifiableList(declaration_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public int getDeclarationCount() { + return declaration_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDeclaration(int index) { + return declaration_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public Builder setDeclaration( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIsMutable(); + declaration_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public Builder setDeclaration( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + ensureDeclarationIsMutable(); + declaration_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public Builder addDeclaration(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIsMutable(); + declaration_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public Builder addDeclaration( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIsMutable(); + declaration_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public Builder addDeclaration( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + ensureDeclarationIsMutable(); + declaration_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public Builder addDeclaration( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + ensureDeclarationIsMutable(); + declaration_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public Builder clearDeclaration() { + declaration_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 1; + */ + public Builder removeDeclaration(int index) { + ensureDeclarationIsMutable(); + declaration_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer) + } + + static { + defaultInstance = new IrDeclarationContainer(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer) + } + + public interface FileEntryOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required string name = 1; + */ + boolean hasName(); + /** + * required string name = 1; + */ + java.lang.String getName(); + /** + * required string name = 1; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry} + * + * 
+   * TODO: extend me.
+   *
+ */ + public static final class FileEntry extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = 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 { + 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 java.lang.Object name_; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + private void initFields() { + name_ = ""; + } + 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; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getNameBytes()); + } + 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 + .computeBytesSize(1, getNameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry} + * + * 
+     * TODO: extend me.
+     *
+ */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntryOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry(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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 1; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + /** + * required string name = 1; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 1; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry) + } + + static { + defaultInstance = new FileEntry(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry) + } + + public interface IrFileOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + java.util.List + getDeclarationIdList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getDeclarationId(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + int getDeclarationIdCount(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + boolean hasFileEntry(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry getFileEntry(); + + /** + * required string fq_name = 3; + * + * 
+     * TODO: we need a better string management. See metadata serialization as an example.
+     *
+ */ + boolean hasFqName(); + /** + * required string fq_name = 3; + * + * 
+     * TODO: we need a better string management. See metadata serialization as an example.
+     *
+ */ + java.lang.String getFqName(); + /** + * required string fq_name = 3; + * + * 
+     * TODO: we need a better string management. See metadata serialization as an example.
+     *
+ */ + org.jetbrains.kotlin.protobuf.ByteString + getFqNameBytes(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile} + */ + public static final class IrFile extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + declarationId_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + declarationId_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.PARSER, extensionRegistry)); + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = fileEntry_.toBuilder(); + } + fileEntry_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(fileEntry_); + fileEntry_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 26: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + fqName_ = 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)) { + declarationId_ = java.util.Collections.unmodifiableList(declarationId_); + } + 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.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public java.util.List getDeclarationIdList() { + return declarationId_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public java.util.List + getDeclarationIdOrBuilderList() { + return declarationId_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public int getDeclarationIdCount() { + return declarationId_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getDeclarationId(int index) { + return declarationId_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqIdOrBuilder getDeclarationIdOrBuilder( + int index) { + return declarationId_.get(index); + } + + public static final int FILE_ENTRY_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry fileEntry_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + public boolean hasFileEntry() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry getFileEntry() { + return fileEntry_; + } + + public static final int FQ_NAME_FIELD_NUMBER = 3; + private java.lang.Object fqName_; + /** + * required string fq_name = 3; + * + * 
+     * TODO: we need a better string management. See metadata serialization as an example.
+     *
+ */ + public boolean hasFqName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string fq_name = 3; + * + * 
+     * TODO: we need a better string management. See metadata serialization as an example.
+     *
+ */ + public java.lang.String getFqName() { + java.lang.Object ref = fqName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + fqName_ = s; + } + return s; + } + } + /** + * required string fq_name = 3; + * + * 
+     * TODO: we need a better string management. See metadata serialization as an example.
+     *
+ */ + public org.jetbrains.kotlin.protobuf.ByteString + getFqNameBytes() { + java.lang.Object ref = fqName_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fqName_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + private void initFields() { + declarationId_ = java.util.Collections.emptyList(); + fileEntry_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.getDefaultInstance(); + fqName_ = ""; + } + 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; + } + for (int i = 0; i < getDeclarationIdCount(); i++) { + if (!getDeclarationId(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getFileEntry().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.writeBytes(3, getFqNameBytes()); + } + 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 + .computeBytesSize(3, getFqNameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFileOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + fqName_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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()) { + bitField0_ |= 0x00000004; + fqName_ = other.fqName_; + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasFileEntry()) { + + return false; + } + if (!hasFqName()) { + + return false; + } + for (int i = 0; i < getDeclarationIdCount(); i++) { + if (!getDeclarationId(i).isInitialized()) { + + return false; + } + } + if (!getFileEntry().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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public java.util.List getDeclarationIdList() { + return java.util.Collections.unmodifiableList(declarationId_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public int getDeclarationIdCount() { + return declarationId_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getDeclarationId(int index) { + return declarationId_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public Builder setDeclarationId( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIdIsMutable(); + declarationId_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public Builder setDeclarationId( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.Builder builderForValue) { + ensureDeclarationIdIsMutable(); + declarationId_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public Builder addDeclarationId(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIdIsMutable(); + declarationId_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public Builder addDeclarationId( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + ensureDeclarationIdIsMutable(); + declarationId_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public Builder addDeclarationId( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.Builder builderForValue) { + ensureDeclarationIdIsMutable(); + declarationId_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public Builder addDeclarationId( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.Builder builderForValue) { + ensureDeclarationIdIsMutable(); + declarationId_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public Builder clearDeclarationId() { + declarationId_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId declaration_id = 1; + */ + public Builder removeDeclarationId(int index) { + ensureDeclarationIdIsMutable(); + declarationId_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry fileEntry_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + public boolean hasFileEntry() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry getFileEntry() { + return fileEntry_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + public Builder setFileEntry(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry value) { + if (value == null) { + throw new NullPointerException(); + } + fileEntry_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + public Builder setFileEntry( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.Builder builderForValue) { + fileEntry_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + public Builder mergeFileEntry(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + fileEntry_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.getDefaultInstance()) { + fileEntry_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.newBuilder(fileEntry_).mergeFrom(value).buildPartial(); + } else { + fileEntry_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FileEntry file_entry = 2; + */ + public Builder clearFileEntry() { + fileEntry_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FileEntry.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private java.lang.Object fqName_ = ""; + /** + * required string fq_name = 3; + * + * 
+       * TODO: we need a better string management. See metadata serialization as an example.
+       *
+ */ + public boolean hasFqName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string fq_name = 3; + * + * 
+       * TODO: we need a better string management. See metadata serialization as an example.
+       *
+ */ + public java.lang.String getFqName() { + java.lang.Object ref = fqName_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + fqName_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string fq_name = 3; + * + * 
+       * TODO: we need a better string management. See metadata serialization as an example.
+       *
+ */ + public org.jetbrains.kotlin.protobuf.ByteString + getFqNameBytes() { + java.lang.Object ref = fqName_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fqName_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string fq_name = 3; + * + * 
+       * TODO: we need a better string management. See metadata serialization as an example.
+       *
+ */ + public Builder setFqName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + fqName_ = value; + + return this; + } + /** + * required string fq_name = 3; + * + * 
+       * TODO: we need a better string management. See metadata serialization as an example.
+       *
+ */ + public Builder clearFqName() { + bitField0_ = (bitField0_ & ~0x00000004); + fqName_ = getDefaultInstance().getFqName(); + + return this; + } + /** + * required string fq_name = 3; + * + * 
+       * TODO: we need a better string management. See metadata serialization as an example.
+       *
+ */ + public Builder setFqNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + fqName_ = value; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile) + } + + static { + defaultInstance = new IrFile(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile) + } + + public interface IrModuleOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrModule) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required string name = 1; + */ + boolean hasName(); + /** + * required string name = 1; + */ + java.lang.String getName(); + /** + * required string name = 1; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + java.util.List + getFileList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile getFile(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + int getFileCount(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + boolean hasSymbolTable(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable getSymbolTable(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + boolean hasTypeTable(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable getTypeTable(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrModule} + */ + public static final class IrModule extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = bs; + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + file_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + file_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile.PARSER, extensionRegistry)); + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = symbolTable_.toBuilder(); + } + symbolTable_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbolTable_); + symbolTable_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = typeTable_.toBuilder(); + } + typeTable_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(typeTable_); + typeTable_ = 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_ & 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 java.lang.Object name_; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int FILE_FIELD_NUMBER = 2; + private java.util.List file_; + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public java.util.List getFileList() { + return file_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public java.util.List + getFileOrBuilderList() { + return file_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public int getFileCount() { + return file_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile getFile(int index) { + return file_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFileOrBuilder getFileOrBuilder( + int index) { + return file_.get(index); + } + + public static final int SYMBOL_TABLE_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable symbolTable_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + public boolean hasSymbolTable() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable getSymbolTable() { + return symbolTable_; + } + + public static final int TYPE_TABLE_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable typeTable_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + public boolean hasTypeTable() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable getTypeTable() { + return typeTable_; + } + + private void initFields() { + name_ = ""; + file_ = java.util.Collections.emptyList(); + symbolTable_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.getDefaultInstance(); + typeTable_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.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; + } + 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.writeBytes(1, getNameBytes()); + } + 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_); + } + 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 + .computeBytesSize(1, getNameBytes()); + } + 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_); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrModule} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrModule) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModuleOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + file_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + symbolTable_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + typeTable_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + + } + 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()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!hasSymbolTable()) { + + return false; + } + if (!hasTypeTable()) { + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrModule) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 1; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + /** + * required string name = 1; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 1; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + 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.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public java.util.List getFileList() { + return java.util.Collections.unmodifiableList(file_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public int getFileCount() { + return file_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile getFile(int index) { + return file_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public Builder setFile( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFileIsMutable(); + file_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public Builder setFile( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile.Builder builderForValue) { + ensureFileIsMutable(); + file_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public Builder addFile(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFileIsMutable(); + file_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public Builder addFile( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFileIsMutable(); + file_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public Builder addFile( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile.Builder builderForValue) { + ensureFileIsMutable(); + file_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public Builder addFile( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFile.Builder builderForValue) { + ensureFileIsMutable(); + file_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public Builder clearFile() { + file_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFile file = 2; + */ + public Builder removeFile(int index) { + ensureFileIsMutable(); + file_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable symbolTable_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + public boolean hasSymbolTable() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable getSymbolTable() { + return symbolTable_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + public Builder setSymbolTable(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable value) { + if (value == null) { + throw new NullPointerException(); + } + symbolTable_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + public Builder setSymbolTable( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.Builder builderForValue) { + symbolTable_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + public Builder mergeSymbolTable(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + symbolTable_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.getDefaultInstance()) { + symbolTable_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.newBuilder(symbolTable_).mergeFrom(value).buildPartial(); + } else { + symbolTable_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable symbol_table = 3; + */ + public Builder clearSymbolTable() { + symbolTable_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable typeTable_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + public boolean hasTypeTable() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable getTypeTable() { + return typeTable_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + public Builder setTypeTable(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable value) { + if (value == null) { + throw new NullPointerException(); + } + typeTable_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + public Builder setTypeTable( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.Builder builderForValue) { + typeTable_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + public Builder mergeTypeTable(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + typeTable_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.getDefaultInstance()) { + typeTable_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.newBuilder(typeTable_).mergeFrom(value).buildPartial(); + } else { + typeTable_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable type_table = 4; + */ + public Builder clearTypeTable() { + typeTable_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrModule) + } + + static { + defaultInstance = new IrModule(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrModule) + } + + public interface IrSymbolDataOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolKind kind = 1; + */ + boolean hasKind(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolKind kind = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind getKind(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + boolean hasUniqId(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getUniqId(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + boolean hasTopLevelUniqId(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getTopLevelUniqId(); + + /** + * optional string fqname = 4; + */ + boolean hasFqname(); + /** + * optional string fqname = 4; + */ + java.lang.String getFqname(); + /** + * optional string fqname = 4; + */ + org.jetbrains.kotlin.protobuf.ByteString + getFqnameBytes(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + boolean hasDescriptorReference(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference getDescriptorReference(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData} + */ + public static final class IrSymbolData extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + kind_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = uniqId_.toBuilder(); + } + uniqId_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(uniqId_); + uniqId_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = topLevelUniqId_.toBuilder(); + } + topLevelUniqId_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(topLevelUniqId_); + topLevelUniqId_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000008; + fqname_ = bs; + break; + } + case 42: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = descriptorReference_.toBuilder(); + } + descriptorReference_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind kind_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolKind kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolKind kind = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind getKind() { + return kind_; + } + + public static final int UNIQ_ID_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId uniqId_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + public boolean hasUniqId() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getUniqId() { + return uniqId_; + } + + public static final int TOP_LEVEL_UNIQ_ID_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId topLevelUniqId_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + public boolean hasTopLevelUniqId() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getTopLevelUniqId() { + return topLevelUniqId_; + } + + public static final int FQNAME_FIELD_NUMBER = 4; + private java.lang.Object fqname_; + /** + * optional string fqname = 4; + */ + public boolean hasFqname() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional string fqname = 4; + */ + public java.lang.String getFqname() { + java.lang.Object ref = fqname_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + fqname_ = s; + } + return s; + } + } + /** + * optional string fqname = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getFqnameBytes() { + java.lang.Object ref = fqname_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fqname_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int DESCRIPTOR_REFERENCE_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference descriptorReference_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + public boolean hasDescriptorReference() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference getDescriptorReference() { + return descriptorReference_; + } + + private void initFields() { + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind.FUNCTION_SYMBOL; + uniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + topLevelUniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + fqname_ = ""; + descriptorReference_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 (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.writeBytes(4, getFqnameBytes()); + } + 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 + .computeBytesSize(4, getFqnameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolDataOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind.FUNCTION_SYMBOL; + bitField0_ = (bitField0_ & ~0x00000001); + uniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + topLevelUniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + fqname_ = ""; + bitField0_ = (bitField0_ & ~0x00000008); + descriptorReference_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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()) { + bitField0_ |= 0x00000008; + fqname_ = other.fqname_; + + } + 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 (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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind.FUNCTION_SYMBOL; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolKind kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolKind kind = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind getKind() { + return kind_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolKind kind = 1; + */ + public Builder setKind(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + kind_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolKind kind = 1; + */ + public Builder clearKind() { + bitField0_ = (bitField0_ & ~0x00000001); + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolKind.FUNCTION_SYMBOL; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId uniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + public boolean hasUniqId() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getUniqId() { + return uniqId_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + public Builder setUniqId(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + uniqId_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + public Builder setUniqId( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.Builder builderForValue) { + uniqId_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + public Builder mergeUniqId(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + uniqId_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance()) { + uniqId_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.newBuilder(uniqId_).mergeFrom(value).buildPartial(); + } else { + uniqId_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId uniq_id = 2; + */ + public Builder clearUniqId() { + uniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId topLevelUniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + public boolean hasTopLevelUniqId() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId getTopLevelUniqId() { + return topLevelUniqId_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + public Builder setTopLevelUniqId(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId value) { + if (value == null) { + throw new NullPointerException(); + } + topLevelUniqId_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + public Builder setTopLevelUniqId( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.Builder builderForValue) { + topLevelUniqId_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + public Builder mergeTopLevelUniqId(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + topLevelUniqId_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance()) { + topLevelUniqId_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.newBuilder(topLevelUniqId_).mergeFrom(value).buildPartial(); + } else { + topLevelUniqId_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.UniqId top_level_uniq_id = 3; + */ + public Builder clearTopLevelUniqId() { + topLevelUniqId_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.UniqId.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private java.lang.Object fqname_ = ""; + /** + * optional string fqname = 4; + */ + public boolean hasFqname() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional string fqname = 4; + */ + public java.lang.String getFqname() { + java.lang.Object ref = fqname_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + fqname_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string fqname = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getFqnameBytes() { + java.lang.Object ref = fqname_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fqname_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * optional string fqname = 4; + */ + public Builder setFqname( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + fqname_ = value; + + return this; + } + /** + * optional string fqname = 4; + */ + public Builder clearFqname() { + bitField0_ = (bitField0_ & ~0x00000008); + fqname_ = getDefaultInstance().getFqname(); + + return this; + } + /** + * optional string fqname = 4; + */ + public Builder setFqnameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + fqname_ = value; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference descriptorReference_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + public boolean hasDescriptorReference() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference getDescriptorReference() { + return descriptorReference_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + public Builder setDescriptorReference(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference value) { + if (value == null) { + throw new NullPointerException(); + } + descriptorReference_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + public Builder setDescriptorReference( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.Builder builderForValue) { + descriptorReference_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + public Builder mergeDescriptorReference(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + descriptorReference_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance()) { + descriptorReference_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.newBuilder(descriptorReference_).mergeFrom(value).buildPartial(); + } else { + descriptorReference_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor_reference = 5; + */ + public Builder clearDescriptorReference() { + descriptorReference_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData) + } + + static { + defaultInstance = new IrSymbolData(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData) + } + + public interface IrSymbolOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 index = 1; + */ + boolean hasIndex(); + /** + * required int32 index = 1; + */ + int getIndex(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol} + */ + public static final class IrSymbol extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrSymbol) + } + + static { + defaultInstance = new IrSymbol(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol) + } + + public interface IrSymbolTableOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + java.util.List + getSymbolsList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData getSymbols(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + int getSymbolsCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable} + */ + public static final class IrSymbolTable extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + symbols_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + symbols_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public java.util.List getSymbolsList() { + return symbols_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public java.util.List + getSymbolsOrBuilderList() { + return symbols_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public int getSymbolsCount() { + return symbols_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData getSymbols(int index) { + return symbols_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTableOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolTable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public java.util.List getSymbolsList() { + return java.util.Collections.unmodifiableList(symbols_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public int getSymbolsCount() { + return symbols_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData getSymbols(int index) { + return symbols_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public Builder setSymbols( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSymbolsIsMutable(); + symbols_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public Builder setSymbols( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData.Builder builderForValue) { + ensureSymbolsIsMutable(); + symbols_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public Builder addSymbols(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSymbolsIsMutable(); + symbols_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public Builder addSymbols( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSymbolsIsMutable(); + symbols_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public Builder addSymbols( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData.Builder builderForValue) { + ensureSymbolsIsMutable(); + symbols_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public Builder addSymbols( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolData.Builder builderForValue) { + ensureSymbolsIsMutable(); + symbols_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public Builder clearSymbols() { + symbols_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolData symbols = 1; + */ + public Builder removeSymbols(int index) { + ensureSymbolsIsMutable(); + symbols_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable) + } + + static { + defaultInstance = new IrSymbolTable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbolTable) + } + + public interface AnnotationsOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + java.util.List + getAnnotationList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall getAnnotation(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + int getAnnotationCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations} + */ + public static final class Annotations extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + annotation_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + annotation_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public java.util.List getAnnotationList() { + return annotation_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public java.util.List + getAnnotationOrBuilderList() { + return annotation_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public int getAnnotationCount() { + return annotation_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall getAnnotation(int index) { + return annotation_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.AnnotationsOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public java.util.List getAnnotationList() { + return java.util.Collections.unmodifiableList(annotation_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public int getAnnotationCount() { + return annotation_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall getAnnotation(int index) { + return annotation_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public Builder setAnnotation( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall value) { + if (value == null) { + throw new NullPointerException(); + } + ensureAnnotationIsMutable(); + annotation_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public Builder setAnnotation( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Builder builderForValue) { + ensureAnnotationIsMutable(); + annotation_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public Builder addAnnotation(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall value) { + if (value == null) { + throw new NullPointerException(); + } + ensureAnnotationIsMutable(); + annotation_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public Builder addAnnotation( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall value) { + if (value == null) { + throw new NullPointerException(); + } + ensureAnnotationIsMutable(); + annotation_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public Builder addAnnotation( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Builder builderForValue) { + ensureAnnotationIsMutable(); + annotation_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public Builder addAnnotation( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Builder builderForValue) { + ensureAnnotationIsMutable(); + annotation_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public Builder clearAnnotation() { + annotation_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall annotation = 1; + */ + public Builder removeAnnotation(int index) { + ensureAnnotationIsMutable(); + annotation_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations) + } + + static { + defaultInstance = new Annotations(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations) + } + + public interface TypeArgumentsOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + java.util.List + getTypeArgumentList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getTypeArgument(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + int getTypeArgumentCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments} + */ + public static final class TypeArguments extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + typeArgument_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + typeArgument_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public java.util.List getTypeArgumentList() { + return typeArgument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public java.util.List + getTypeArgumentOrBuilderList() { + return typeArgument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public int getTypeArgumentCount() { + return typeArgument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getTypeArgument(int index) { + return typeArgument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArgumentsOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public java.util.List getTypeArgumentList() { + return java.util.Collections.unmodifiableList(typeArgument_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public int getTypeArgumentCount() { + return typeArgument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getTypeArgument(int index) { + return typeArgument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public Builder setTypeArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeArgumentIsMutable(); + typeArgument_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public Builder setTypeArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + ensureTypeArgumentIsMutable(); + typeArgument_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public Builder addTypeArgument(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeArgumentIsMutable(); + typeArgument_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public Builder addTypeArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeArgumentIsMutable(); + typeArgument_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public Builder addTypeArgument( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + ensureTypeArgumentIsMutable(); + typeArgument_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public Builder addTypeArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + ensureTypeArgumentIsMutable(); + typeArgument_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public Builder clearTypeArgument() { + typeArgument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type_argument = 1; + */ + public Builder removeTypeArgument(int index) { + ensureTypeArgumentIsMutable(); + typeArgument_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments) + } + + static { + defaultInstance = new TypeArguments(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments) + } + + public interface IrStarProjectionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional bool void = 1; + */ + boolean hasVoid(); + /** + * optional bool void = 1; + */ + boolean getVoid(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection} + */ + public static final class IrStarProjection extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjectionOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStarProjection) + } + + static { + defaultInstance = new IrStarProjection(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection) + } + + public interface IrTypeProjectionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 1; + */ + boolean hasVariance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance getVariance(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection} + */ + public static final class IrTypeProjection extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + variance_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance variance_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 1; + */ + public boolean hasVariance() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance getVariance() { + return variance_; + } + + public static final int TYPE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType() { + return type_; + } + + private void initFields() { + variance_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance.IN; + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjectionOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + variance_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance.IN; + bitField0_ = (bitField0_ & ~0x00000001); + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance variance_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance.IN; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 1; + */ + public boolean hasVariance() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance getVariance() { + return variance_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 1; + */ + public Builder setVariance(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + variance_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 1; + */ + public Builder clearVariance() { + bitField0_ = (bitField0_ & ~0x00000001); + variance_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance.IN; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public Builder setType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public Builder setType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public Builder mergeType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + type_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection) + } + + static { + defaultInstance = new IrTypeProjection(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection) + } + + public interface IrTypeArgumentOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + boolean hasStar(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection getStar(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + boolean hasType(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection getType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument} + */ + public static final class IrTypeArgument extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection.Builder subBuilder = null; + if (kindCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection) kind_); + kind_ = subBuilder.buildPartial(); + } + kindCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection.Builder subBuilder = null; + if (kindCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + public boolean hasStar() { + return kindCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection getStar() { + if (kindCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection.getDefaultInstance(); + } + + public static final int TYPE_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + public boolean hasType() { + return kindCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection getType() { + if (kindCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection) kind_); + } + if (kindCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection) kind_); + } + if (kindCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgumentOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + public boolean hasStar() { + return kindCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection getStar() { + if (kindCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + public Builder setStar(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + public Builder setStar( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + public Builder mergeStar(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection value) { + if (kindCase_ == 1 && + kind_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStarProjection) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStarProjection star = 1; + */ + public Builder clearStar() { + if (kindCase_ == 1) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + public boolean hasType() { + return kindCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection getType() { + if (kindCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + public Builder setType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + public Builder setType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + public Builder mergeType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection value) { + if (kindCase_ == 2 && + kind_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeProjection) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeProjection type = 2; + */ + public Builder clearType() { + if (kindCase_ == 2) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument) + } + + static { + defaultInstance = new IrTypeArgument(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument) + } + + public interface IrSimpleTypeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + boolean hasAnnotations(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + boolean hasClassifier(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getClassifier(); + + /** + * required bool has_question_mark = 3; + */ + boolean hasHasQuestionMark(); + /** + * required bool has_question_mark = 3; + */ + boolean getHasQuestionMark(); + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + java.util.List + getArgumentList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument getArgument(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + int getArgumentCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType} + */ + public static final class IrSimpleType extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = annotations_.toBuilder(); + } + annotations_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(annotations_); + annotations_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = classifier_.toBuilder(); + } + classifier_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations annotations_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations() { + return annotations_; + } + + public static final int CLASSIFIER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol classifier_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + public boolean hasClassifier() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public java.util.List getArgumentList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public java.util.List + getArgumentOrBuilderList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgumentOrBuilder getArgumentOrBuilder( + int index) { + return argument_.get(index); + } + + private void initFields() { + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + classifier_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleTypeOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + classifier_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations() { + return annotations_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder setAnnotations(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations value) { + if (value == null) { + throw new NullPointerException(); + } + annotations_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder setAnnotations( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.Builder builderForValue) { + annotations_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder mergeAnnotations(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + annotations_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance()) { + annotations_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.newBuilder(annotations_).mergeFrom(value).buildPartial(); + } else { + annotations_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder clearAnnotations() { + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol classifier_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + public boolean hasClassifier() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getClassifier() { + return classifier_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + public Builder setClassifier(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + classifier_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + public Builder setClassifier( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + classifier_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + public Builder mergeClassifier(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + classifier_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + classifier_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(classifier_).mergeFrom(value).buildPartial(); + } else { + classifier_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol classifier = 2; + */ + public Builder clearClassifier() { + classifier_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public java.util.List getArgumentList() { + return java.util.Collections.unmodifiableList(argument_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public Builder addArgument(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public Builder addArgument( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeArgument.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public Builder clearArgument() { + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeArgument argument = 4; + */ + public Builder removeArgument(int index) { + ensureArgumentIsMutable(); + argument_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType) + } + + static { + defaultInstance = new IrSimpleType(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType) + } + + public interface IrDynamicTypeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + boolean hasAnnotations(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType} + */ + public static final class IrDynamicType extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = annotations_.toBuilder(); + } + annotations_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations annotations_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations() { + return annotations_; + } + + private void initFields() { + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicTypeOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations() { + return annotations_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder setAnnotations(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations value) { + if (value == null) { + throw new NullPointerException(); + } + annotations_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder setAnnotations( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.Builder builderForValue) { + annotations_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder mergeAnnotations(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + annotations_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance()) { + annotations_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.newBuilder(annotations_).mergeFrom(value).buildPartial(); + } else { + annotations_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder clearAnnotations() { + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType) + } + + static { + defaultInstance = new IrDynamicType(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType) + } + + public interface IrErrorTypeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + boolean hasAnnotations(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType} + */ + public static final class IrErrorType extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = annotations_.toBuilder(); + } + annotations_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations annotations_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations() { + return annotations_; + } + + private void initFields() { + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorTypeOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations() { + return annotations_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder setAnnotations(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations value) { + if (value == null) { + throw new NullPointerException(); + } + annotations_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder setAnnotations( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.Builder builderForValue) { + annotations_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder mergeAnnotations(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + annotations_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance()) { + annotations_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.newBuilder(annotations_).mergeFrom(value).buildPartial(); + } else { + annotations_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 1; + */ + public Builder clearAnnotations() { + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType) + } + + static { + defaultInstance = new IrErrorType(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType) + } + + public interface IrTypeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + boolean hasSimple(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType getSimple(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + boolean hasDynamic(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType getDynamic(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + boolean hasError(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType getError(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType} + */ + public static final class IrType extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType.Builder subBuilder = null; + if (kindCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType) kind_); + kind_ = subBuilder.buildPartial(); + } + kindCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType.Builder subBuilder = null; + if (kindCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType) kind_); + kind_ = subBuilder.buildPartial(); + } + kindCase_ = 2; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType.Builder subBuilder = null; + if (kindCase_ == 3) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType) kind_).toBuilder(); + } + kind_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + public boolean hasSimple() { + return kindCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType getSimple() { + if (kindCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType.getDefaultInstance(); + } + + public static final int DYNAMIC_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + public boolean hasDynamic() { + return kindCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType getDynamic() { + if (kindCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType.getDefaultInstance(); + } + + public static final int ERROR_FIELD_NUMBER = 3; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + public boolean hasError() { + return kindCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType getError() { + if (kindCase_ == 3) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType) kind_); + } + if (kindCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType) kind_); + } + if (kindCase_ == 3) { + output.writeMessage(3, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType) kind_); + } + if (kindCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType) kind_); + } + if (kindCase_ == 3) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + public boolean hasSimple() { + return kindCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType getSimple() { + if (kindCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + public Builder setSimple(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + public Builder setSimple( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + public Builder mergeSimple(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType value) { + if (kindCase_ == 1 && + kind_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSimpleType) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSimpleType simple = 1; + */ + public Builder clearSimple() { + if (kindCase_ == 1) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + public boolean hasDynamic() { + return kindCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType getDynamic() { + if (kindCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + public Builder setDynamic(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + public Builder setDynamic( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + public Builder mergeDynamic(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType value) { + if (kindCase_ == 2 && + kind_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicType) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicType dynamic = 2; + */ + public Builder clearDynamic() { + if (kindCase_ == 2) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + public boolean hasError() { + return kindCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType getError() { + if (kindCase_ == 3) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType) kind_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + public Builder setError(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType value) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + + kindCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + public Builder setError( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType.Builder builderForValue) { + kind_ = builderForValue.build(); + + kindCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + public Builder mergeError(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType value) { + if (kindCase_ == 3 && + kind_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType.getDefaultInstance()) { + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrErrorType) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + + kindCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrErrorType error = 3; + */ + public Builder clearError() { + if (kindCase_ == 3) { + kindCase_ = 0; + kind_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType) + } + + static { + defaultInstance = new IrType(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType) + } + + public interface IrTypeTableOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + java.util.List + getTypesList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType getTypes(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + int getTypesCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable} + */ + public static final class IrTypeTable extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + types_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + types_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public java.util.List getTypesList() { + return types_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public java.util.List + getTypesOrBuilderList() { + return types_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public int getTypesCount() { + return types_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType getTypes(int index) { + return types_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTableOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeTable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public java.util.List getTypesList() { + return java.util.Collections.unmodifiableList(types_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public int getTypesCount() { + return types_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType getTypes(int index) { + return types_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public Builder setTypes( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypesIsMutable(); + types_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public Builder setTypes( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType.Builder builderForValue) { + ensureTypesIsMutable(); + types_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public Builder addTypes(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypesIsMutable(); + types_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public Builder addTypes( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypesIsMutable(); + types_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public Builder addTypes( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType.Builder builderForValue) { + ensureTypesIsMutable(); + types_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public Builder addTypes( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrType.Builder builderForValue) { + ensureTypesIsMutable(); + types_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public Builder clearTypes() { + types_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrType types = 1; + */ + public Builder removeTypes(int index) { + ensureTypesIsMutable(); + types_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable) + } + + static { + defaultInstance = new IrTypeTable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeTable) + } + + public interface IrTypeIndexOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 index = 1; + */ + boolean hasIndex(); + /** + * required int32 index = 1; + */ + int getIndex(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex} + */ + public static final class IrTypeIndex extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndexOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrTypeIndex) + } + + static { + defaultInstance = new IrTypeIndex(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex) + } + + public interface IrBreakOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 loop_id = 1; + */ + boolean hasLoopId(); + /** + * required int32 loop_id = 1; + */ + int getLoopId(); + + /** + * optional string label = 2; + */ + boolean hasLabel(); + /** + * optional string label = 2; + */ + java.lang.String getLabel(); + /** + * optional string label = 2; + */ + org.jetbrains.kotlin.protobuf.ByteString + getLabelBytes(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak} + */ + public static final class IrBreak extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + loopId_ = input.readInt32(); + break; + } + case 18: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + label_ = 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 { + 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 java.lang.Object label_; + /** + * optional string label = 2; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string label = 2; + */ + public java.lang.String getLabel() { + java.lang.Object ref = label_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + label_ = s; + } + return s; + } + } + /** + * optional string label = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getLabelBytes() { + java.lang.Object ref = label_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + label_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + private void initFields() { + loopId_ = 0; + label_ = ""; + } + 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; + } + 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.writeBytes(2, getLabelBytes()); + } + 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 + .computeBytesSize(2, getLabelBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreakOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak.getDefaultInstance()) return this; + if (other.hasLoopId()) { + setLoopId(other.getLoopId()); + } + if (other.hasLabel()) { + bitField0_ |= 0x00000002; + label_ = other.label_; + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasLoopId()) { + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 java.lang.Object label_ = ""; + /** + * optional string label = 2; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string label = 2; + */ + public java.lang.String getLabel() { + java.lang.Object ref = label_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + label_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string label = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getLabelBytes() { + java.lang.Object ref = label_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + label_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * optional string label = 2; + */ + public Builder setLabel( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + label_ = value; + + return this; + } + /** + * optional string label = 2; + */ + public Builder clearLabel() { + bitField0_ = (bitField0_ & ~0x00000002); + label_ = getDefaultInstance().getLabel(); + + return this; + } + /** + * optional string label = 2; + */ + public Builder setLabelBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + label_ = value; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak) + } + + static { + defaultInstance = new IrBreak(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak) + } + + public interface IrBlockOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + java.util.List + getStatementList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getStatement(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + int getStatementCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock} + */ + public static final class IrBlock extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public java.util.List getStatementList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public java.util.List + getStatementOrBuilderList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public java.util.List getStatementList() { + return java.util.Collections.unmodifiableList(statement_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public Builder addStatement(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public Builder addStatement( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public Builder clearStatement() { + statement_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 2; + */ + public Builder removeStatement(int index) { + ensureStatementIsMutable(); + statement_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock) + } + + static { + defaultInstance = new IrBlock(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock) + } + + public interface MemberAccessCommonOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + boolean hasDispatchReceiver(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getDispatchReceiver(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + boolean hasExtensionReceiver(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExtensionReceiver(); + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + java.util.List + getValueArgumentList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression getValueArgument(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + int getValueArgumentCount(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + boolean hasTypeArguments(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments getTypeArguments(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon} + */ + public static final class MemberAccessCommon extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = dispatchReceiver_.toBuilder(); + } + dispatchReceiver_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(dispatchReceiver_); + dispatchReceiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = extensionReceiver_.toBuilder(); + } + extensionReceiver_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression.PARSER, extensionRegistry)); + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = typeArguments_.toBuilder(); + } + typeArguments_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression dispatchReceiver_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + public boolean hasDispatchReceiver() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getDispatchReceiver() { + return dispatchReceiver_; + } + + public static final int EXTENSION_RECEIVER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression extensionReceiver_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + public boolean hasExtensionReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExtensionReceiver() { + return extensionReceiver_; + } + + public static final int VALUE_ARGUMENT_FIELD_NUMBER = 3; + private java.util.List valueArgument_; + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public java.util.List getValueArgumentList() { + return valueArgument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public java.util.List + getValueArgumentOrBuilderList() { + return valueArgument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public int getValueArgumentCount() { + return valueArgument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression getValueArgument(int index) { + return valueArgument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpressionOrBuilder getValueArgumentOrBuilder( + int index) { + return valueArgument_.get(index); + } + + public static final int TYPE_ARGUMENTS_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments typeArguments_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + public boolean hasTypeArguments() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments getTypeArguments() { + return typeArguments_; + } + + private void initFields() { + dispatchReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + extensionReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + valueArgument_ = java.util.Collections.emptyList(); + typeArguments_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommonOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + dispatchReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + extensionReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + valueArgument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + typeArguments_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression dispatchReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + public boolean hasDispatchReceiver() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getDispatchReceiver() { + return dispatchReceiver_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + public Builder setDispatchReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + dispatchReceiver_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + public Builder setDispatchReceiver( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + dispatchReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + public Builder mergeDispatchReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + dispatchReceiver_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + dispatchReceiver_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(dispatchReceiver_).mergeFrom(value).buildPartial(); + } else { + dispatchReceiver_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression dispatch_receiver = 1; + */ + public Builder clearDispatchReceiver() { + dispatchReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression extensionReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + public boolean hasExtensionReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExtensionReceiver() { + return extensionReceiver_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + public Builder setExtensionReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + extensionReceiver_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + public Builder setExtensionReceiver( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + extensionReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + public Builder mergeExtensionReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + extensionReceiver_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + extensionReceiver_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(extensionReceiver_).mergeFrom(value).buildPartial(); + } else { + extensionReceiver_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression extension_receiver = 2; + */ + public Builder clearExtensionReceiver() { + extensionReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public java.util.List getValueArgumentList() { + return java.util.Collections.unmodifiableList(valueArgument_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public int getValueArgumentCount() { + return valueArgument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression getValueArgument(int index) { + return valueArgument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public Builder setValueArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueArgumentIsMutable(); + valueArgument_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public Builder setValueArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression.Builder builderForValue) { + ensureValueArgumentIsMutable(); + valueArgument_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public Builder addValueArgument(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueArgumentIsMutable(); + valueArgument_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public Builder addValueArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueArgumentIsMutable(); + valueArgument_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public Builder addValueArgument( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression.Builder builderForValue) { + ensureValueArgumentIsMutable(); + valueArgument_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public Builder addValueArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression.Builder builderForValue) { + ensureValueArgumentIsMutable(); + valueArgument_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public Builder clearValueArgument() { + valueArgument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression value_argument = 3; + */ + public Builder removeValueArgument(int index) { + ensureValueArgumentIsMutable(); + valueArgument_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments typeArguments_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + public boolean hasTypeArguments() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments getTypeArguments() { + return typeArguments_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + public Builder setTypeArguments(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments value) { + if (value == null) { + throw new NullPointerException(); + } + typeArguments_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + public Builder setTypeArguments( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments.Builder builderForValue) { + typeArguments_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + public Builder mergeTypeArguments(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + typeArguments_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments.getDefaultInstance()) { + typeArguments_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments.newBuilder(typeArguments_).mergeFrom(value).buildPartial(); + } else { + typeArguments_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.TypeArguments type_arguments = 4; + */ + public Builder clearTypeArguments() { + typeArguments_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.TypeArguments.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon) + } + + static { + defaultInstance = new MemberAccessCommon(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon) + } + + public interface IrCallOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall.Primitive kind = 1; + */ + boolean hasKind(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall.Primitive kind = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive getKind(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + boolean hasSuper(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSuper(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall} + */ + public static final class IrCall extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + kind_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(memberAccess_); + memberAccess_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = super_.toBuilder(); + } + super_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrCall.Primitive) + } + + private int bitField0_; + public static final int KIND_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive kind_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall.Primitive kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall.Primitive kind = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive getKind() { + return kind_; + } + + public static final int SYMBOL_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + public static final int SUPER_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol super_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + public boolean hasSuper() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSuper() { + return super_; + } + + private void initFields() { + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive.NOT_PRIMITIVE; + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + super_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCallOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive.NOT_PRIMITIVE; + bitField0_ = (bitField0_ & ~0x00000001); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + super_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive.NOT_PRIMITIVE; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall.Primitive kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall.Primitive kind = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive getKind() { + return kind_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall.Primitive kind = 1; + */ + public Builder setKind(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + kind_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall.Primitive kind = 1; + */ + public Builder clearKind() { + bitField0_ = (bitField0_ & ~0x00000001); + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Primitive.NOT_PRIMITIVE; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + memberAccess_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol super_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + public boolean hasSuper() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSuper() { + return super_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + public Builder setSuper(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + super_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + public Builder setSuper( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + super_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + public Builder mergeSuper(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + super_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + super_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(super_).mergeFrom(value).buildPartial(); + } else { + super_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 4; + */ + public Builder clearSuper() { + super_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall) + } + + static { + defaultInstance = new IrCall(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall) + } + + public interface IrFunctionReferenceOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * optional string origin = 2; + */ + boolean hasOrigin(); + /** + * optional string origin = 2; + */ + java.lang.String getOrigin(); + /** + * optional string origin = 2; + */ + org.jetbrains.kotlin.protobuf.ByteString + getOriginBytes(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference} + */ + public static final class IrFunctionReference extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + origin_ = bs; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int ORIGIN_FIELD_NUMBER = 2; + private java.lang.Object origin_; + /** + * optional string origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string origin = 2; + */ + public java.lang.String getOrigin() { + java.lang.Object ref = origin_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + origin_ = s; + } + return s; + } + } + /** + * optional string origin = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getOriginBytes() { + java.lang.Object ref = origin_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + origin_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + origin_ = ""; + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.writeBytes(2, getOriginBytes()); + } + 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 + .computeBytesSize(2, getOriginBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReferenceOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + origin_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasOrigin()) { + bitField0_ |= 0x00000002; + origin_ = other.origin_; + + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private java.lang.Object origin_ = ""; + /** + * optional string origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string origin = 2; + */ + public java.lang.String getOrigin() { + java.lang.Object ref = origin_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + origin_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string origin = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getOriginBytes() { + java.lang.Object ref = origin_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + origin_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * optional string origin = 2; + */ + public Builder setOrigin( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + origin_ = value; + + return this; + } + /** + * optional string origin = 2; + */ + public Builder clearOrigin() { + bitField0_ = (bitField0_ & ~0x00000002); + origin_ = getDefaultInstance().getOrigin(); + + return this; + } + /** + * optional string origin = 2; + */ + public Builder setOriginBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + origin_ = value; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + memberAccess_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 3; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference) + } + + static { + defaultInstance = new IrFunctionReference(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference) + } + + public interface IrPropertyReferenceOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + boolean hasField(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getField(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + boolean hasGetter(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getGetter(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + boolean hasSetter(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSetter(); + + /** + * optional string origin = 4; + */ + boolean hasOrigin(); + /** + * optional string origin = 4; + */ + java.lang.String getOrigin(); + /** + * optional string origin = 4; + */ + org.jetbrains.kotlin.protobuf.ByteString + getOriginBytes(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference} + */ + public static final class IrPropertyReference extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = field_.toBuilder(); + } + field_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(field_); + field_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = getter_.toBuilder(); + } + getter_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(getter_); + getter_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = setter_.toBuilder(); + } + setter_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(setter_); + setter_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000008; + origin_ = bs; + break; + } + case 42: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(memberAccess_); + memberAccess_ = 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 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol field_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + public boolean hasField() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getField() { + return field_; + } + + public static final int GETTER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getter_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + public boolean hasGetter() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getGetter() { + return getter_; + } + + public static final int SETTER_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol setter_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + public boolean hasSetter() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSetter() { + return setter_; + } + + public static final int ORIGIN_FIELD_NUMBER = 4; + private java.lang.Object origin_; + /** + * optional string origin = 4; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional string origin = 4; + */ + public java.lang.String getOrigin() { + java.lang.Object ref = origin_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + origin_ = s; + } + return s; + } + } + /** + * optional string origin = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getOriginBytes() { + java.lang.Object ref = origin_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + origin_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + private void initFields() { + field_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + getter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + setter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + origin_ = ""; + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.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 (!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, field_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, getter_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, setter_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeBytes(4, getOriginBytes()); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(5, 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, 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 + .computeBytesSize(4, getOriginBytes()); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReferenceOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + field_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + getter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + setter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + origin_ = ""; + bitField0_ = (bitField0_ & ~0x00000008); + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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()) { + bitField0_ |= 0x00000008; + origin_ = other.origin_; + + } + if (other.hasMemberAccess()) { + mergeMemberAccess(other.getMemberAccess()); + } + 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 (!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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol field_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + public boolean hasField() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getField() { + return field_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + public Builder setField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + field_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + public Builder setField( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + field_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + public Builder mergeField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + field_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + field_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(field_).mergeFrom(value).buildPartial(); + } else { + field_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol field = 1; + */ + public Builder clearField() { + field_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + public boolean hasGetter() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getGetter() { + return getter_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + public Builder setGetter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + getter_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + public Builder setGetter( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + getter_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + public Builder mergeGetter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + getter_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + getter_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(getter_).mergeFrom(value).buildPartial(); + } else { + getter_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol getter = 2; + */ + public Builder clearGetter() { + getter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol setter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + public boolean hasSetter() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSetter() { + return setter_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + public Builder setSetter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + setter_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + public Builder setSetter( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + setter_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + public Builder mergeSetter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + setter_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + setter_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(setter_).mergeFrom(value).buildPartial(); + } else { + setter_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol setter = 3; + */ + public Builder clearSetter() { + setter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private java.lang.Object origin_ = ""; + /** + * optional string origin = 4; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional string origin = 4; + */ + public java.lang.String getOrigin() { + java.lang.Object ref = origin_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + origin_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string origin = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getOriginBytes() { + java.lang.Object ref = origin_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + origin_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * optional string origin = 4; + */ + public Builder setOrigin( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + origin_ = value; + + return this; + } + /** + * optional string origin = 4; + */ + public Builder clearOrigin() { + bitField0_ = (bitField0_ & ~0x00000008); + origin_ = getDefaultInstance().getOrigin(); + + return this; + } + /** + * optional string origin = 4; + */ + public Builder setOriginBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + origin_ = value; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + memberAccess_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 5; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference) + } + + static { + defaultInstance = new IrPropertyReference(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference) + } + + public interface IrCompositeOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + java.util.List + getStatementList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getStatement(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + int getStatementCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite} + */ + public static final class IrComposite extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + statement_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public java.util.List getStatementList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public java.util.List + getStatementOrBuilderList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCompositeOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public java.util.List getStatementList() { + return java.util.Collections.unmodifiableList(statement_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder addStatement(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder addStatement( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder clearStatement() { + statement_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder removeStatement(int index) { + ensureStatementIsMutable(); + statement_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite) + } + + static { + defaultInstance = new IrComposite(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite) + } + + public interface IrClassReferenceOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + boolean hasClassSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getClassSymbol(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + boolean hasClassType(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getClassType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference} + */ + public static final class IrClassReference extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = classSymbol_.toBuilder(); + } + classSymbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(classSymbol_); + classSymbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = classType_.toBuilder(); + } + classType_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol classSymbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + public boolean hasClassSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getClassSymbol() { + return classSymbol_; + } + + public static final int CLASS_TYPE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex classType_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + public boolean hasClassType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getClassType() { + return classType_; + } + + private void initFields() { + classSymbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + classType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReferenceOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + classSymbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + classType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol classSymbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + public boolean hasClassSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getClassSymbol() { + return classSymbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + public Builder setClassSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + classSymbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + public Builder setClassSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + classSymbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + public Builder mergeClassSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + classSymbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + classSymbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(classSymbol_).mergeFrom(value).buildPartial(); + } else { + classSymbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol class_symbol = 1; + */ + public Builder clearClassSymbol() { + classSymbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex classType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + public boolean hasClassType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getClassType() { + return classType_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + public Builder setClassType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + classType_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + public Builder setClassType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + classType_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + public Builder mergeClassType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + classType_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + classType_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(classType_).mergeFrom(value).buildPartial(); + } else { + classType_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex class_type = 2; + */ + public Builder clearClassType() { + classType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference) + } + + static { + defaultInstance = new IrClassReference(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference) + } + + public interface IrConstOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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 string string = 10; + */ + boolean hasString(); + /** + * optional string string = 10; + */ + java.lang.String getString(); + /** + * optional string string = 10; + */ + org.jetbrains.kotlin.protobuf.ByteString + getStringBytes(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst} + */ + public static final class IrConst extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + 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.protobuf.ByteString bs = input.readBytes(); + valueCase_ = 10; + value_ = 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 { + 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 string string = 10; + */ + public boolean hasString() { + return valueCase_ == 10; + } + /** + * optional string string = 10; + */ + public java.lang.String getString() { + java.lang.Object ref = ""; + if (valueCase_ == 10) { + ref = value_; + } + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8() && (valueCase_ == 10)) { + value_ = s; + } + return s; + } + } + /** + * optional string string = 10; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getStringBytes() { + java.lang.Object ref = ""; + if (valueCase_ == 10) { + ref = value_; + } + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (valueCase_ == 10) { + value_ = b; + } + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + 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(); + 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.writeBytes(10, getStringBytes()); + } + 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 + .computeBytesSize(10, getStringBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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: { + valueCase_ = 10; + value_ = other.value_; + + break; + } + case VALUE_NOT_SET: { + break; + } + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 string string = 10; + */ + public boolean hasString() { + return valueCase_ == 10; + } + /** + * optional string string = 10; + */ + public java.lang.String getString() { + java.lang.Object ref = ""; + if (valueCase_ == 10) { + ref = value_; + } + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (valueCase_ == 10) { + if (bs.isValidUtf8()) { + value_ = s; + } + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string string = 10; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getStringBytes() { + java.lang.Object ref = ""; + if (valueCase_ == 10) { + ref = value_; + } + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (valueCase_ == 10) { + value_ = b; + } + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * optional string string = 10; + */ + public Builder setString( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + valueCase_ = 10; + value_ = value; + + return this; + } + /** + * optional string string = 10; + */ + public Builder clearString() { + if (valueCase_ == 10) { + valueCase_ = 0; + value_ = null; + + } + return this; + } + /** + * optional string string = 10; + */ + public Builder setStringBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + valueCase_ = 10; + value_ = value; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst) + } + + static { + defaultInstance = new IrConst(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst) + } + + public interface IrContinueOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 loop_id = 1; + */ + boolean hasLoopId(); + /** + * required int32 loop_id = 1; + */ + int getLoopId(); + + /** + * optional string label = 2; + */ + boolean hasLabel(); + /** + * optional string label = 2; + */ + java.lang.String getLabel(); + /** + * optional string label = 2; + */ + org.jetbrains.kotlin.protobuf.ByteString + getLabelBytes(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue} + */ + public static final class IrContinue extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + loopId_ = input.readInt32(); + break; + } + case 18: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + label_ = 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 { + 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 java.lang.Object label_; + /** + * optional string label = 2; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string label = 2; + */ + public java.lang.String getLabel() { + java.lang.Object ref = label_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + label_ = s; + } + return s; + } + } + /** + * optional string label = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getLabelBytes() { + java.lang.Object ref = label_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + label_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + private void initFields() { + loopId_ = 0; + label_ = ""; + } + 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; + } + 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.writeBytes(2, getLabelBytes()); + } + 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 + .computeBytesSize(2, getLabelBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinueOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue.getDefaultInstance()) return this; + if (other.hasLoopId()) { + setLoopId(other.getLoopId()); + } + if (other.hasLabel()) { + bitField0_ |= 0x00000002; + label_ = other.label_; + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasLoopId()) { + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 java.lang.Object label_ = ""; + /** + * optional string label = 2; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string label = 2; + */ + public java.lang.String getLabel() { + java.lang.Object ref = label_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + label_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string label = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getLabelBytes() { + java.lang.Object ref = label_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + label_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * optional string label = 2; + */ + public Builder setLabel( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + label_ = value; + + return this; + } + /** + * optional string label = 2; + */ + public Builder clearLabel() { + bitField0_ = (bitField0_ & ~0x00000002); + label_ = getDefaultInstance().getLabel(); + + return this; + } + /** + * optional string label = 2; + */ + public Builder setLabelBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + label_ = value; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue) + } + + static { + defaultInstance = new IrContinue(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue) + } + + public interface IrDelegatingConstructorCallOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall} + */ + public static final class IrDelegatingConstructorCall extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCallOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + memberAccess_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall) + } + + static { + defaultInstance = new IrDelegatingConstructorCall(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall) + } + + public interface IrDoWhileOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + boolean hasLoop(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop getLoop(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile} + */ + public static final class IrDoWhile extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = loop_.toBuilder(); + } + loop_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop loop_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public boolean hasLoop() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop getLoop() { + return loop_; + } + + private void initFields() { + loop_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhileOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + loop_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop loop_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public boolean hasLoop() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop getLoop() { + return loop_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public Builder setLoop(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop value) { + if (value == null) { + throw new NullPointerException(); + } + loop_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public Builder setLoop( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.Builder builderForValue) { + loop_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public Builder mergeLoop(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + loop_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance()) { + loop_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.newBuilder(loop_).mergeFrom(value).buildPartial(); + } else { + loop_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public Builder clearLoop() { + loop_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile) + } + + static { + defaultInstance = new IrDoWhile(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile) + } + + public interface IrEnumConstructorCallOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + boolean hasMemberAccess(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall} + */ + public static final class IrEnumConstructorCall extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = memberAccess_.toBuilder(); + } + memberAccess_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int MEMBER_ACCESS_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCallOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public boolean hasMemberAccess() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon getMemberAccess() { + return memberAccess_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public Builder setMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + memberAccess_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public Builder setMemberAccess( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.Builder builderForValue) { + memberAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public Builder mergeMemberAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + memberAccess_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance()) { + memberAccess_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.newBuilder(memberAccess_).mergeFrom(value).buildPartial(); + } else { + memberAccess_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.MemberAccessCommon member_access = 2; + */ + public Builder clearMemberAccess() { + memberAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.MemberAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall) + } + + static { + defaultInstance = new IrEnumConstructorCall(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall) + } + + public interface IrGetClassOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + boolean hasArgument(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getArgument(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass} + */ + public static final class IrGetClass extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = argument_.toBuilder(); + } + argument_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression argument_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public boolean hasArgument() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getArgument() { + return argument_; + } + + private void initFields() { + argument_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClassOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + argument_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression argument_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public boolean hasArgument() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getArgument() { + return argument_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder setArgument(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + argument_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder setArgument( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + argument_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder mergeArgument(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + argument_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + argument_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(argument_).mergeFrom(value).buildPartial(); + } else { + argument_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder clearArgument() { + argument_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass) + } + + static { + defaultInstance = new IrGetClass(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass) + } + + public interface IrGetEnumValueOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue} + */ + public static final class IrGetEnumValue extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValueOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue) + } + + static { + defaultInstance = new IrGetEnumValue(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue) + } + + public interface FieldAccessCommonOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + boolean hasSuper(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSuper(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + boolean hasReceiver(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getReceiver(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon} + */ + public static final class FieldAccessCommon extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = super_.toBuilder(); + } + super_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(super_); + super_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = receiver_.toBuilder(); + } + receiver_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int SUPER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol super_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + public boolean hasSuper() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSuper() { + return super_; + } + + public static final int RECEIVER_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression receiver_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getReceiver() { + return receiver_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + super_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + receiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommonOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + super_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + receiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol super_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + public boolean hasSuper() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSuper() { + return super_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + public Builder setSuper(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + super_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + public Builder setSuper( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + super_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + public Builder mergeSuper(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + super_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + super_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(super_).mergeFrom(value).buildPartial(); + } else { + super_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol super = 2; + */ + public Builder clearSuper() { + super_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression receiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getReceiver() { + return receiver_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + public Builder setReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + receiver_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + public Builder setReceiver( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + receiver_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + public Builder mergeReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + receiver_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + receiver_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(receiver_).mergeFrom(value).buildPartial(); + } else { + receiver_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 3; + */ + public Builder clearReceiver() { + receiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon) + } + + static { + defaultInstance = new FieldAccessCommon(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon) + } + + public interface IrGetFieldOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + boolean hasFieldAccess(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon getFieldAccess(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField} + */ + public static final class IrGetField extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = fieldAccess_.toBuilder(); + } + fieldAccess_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon fieldAccess_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public boolean hasFieldAccess() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon getFieldAccess() { + return fieldAccess_; + } + + private void initFields() { + fieldAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetFieldOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + fieldAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon fieldAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public boolean hasFieldAccess() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon getFieldAccess() { + return fieldAccess_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public Builder setFieldAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + fieldAccess_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public Builder setFieldAccess( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.Builder builderForValue) { + fieldAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public Builder mergeFieldAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + fieldAccess_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance()) { + fieldAccess_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.newBuilder(fieldAccess_).mergeFrom(value).buildPartial(); + } else { + fieldAccess_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public Builder clearFieldAccess() { + fieldAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField) + } + + static { + defaultInstance = new IrGetField(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField) + } + + public interface IrGetValueOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue} + */ + public static final class IrGetValue extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValueOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue) + } + + static { + defaultInstance = new IrGetValue(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue) + } + + public interface IrGetObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject} + */ + public static final class IrGetObject extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObjectOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject) + } + + static { + defaultInstance = new IrGetObject(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject) + } + + public interface IrInstanceInitializerCallOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall} + */ + public static final class IrInstanceInitializerCall extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCallOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall) + } + + static { + defaultInstance = new IrInstanceInitializerCall(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall) + } + + public interface LoopOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required int32 loop_id = 1; + */ + boolean hasLoopId(); + /** + * required int32 loop_id = 1; + */ + int getLoopId(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + boolean hasCondition(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getCondition(); + + /** + * optional string label = 3; + */ + boolean hasLabel(); + /** + * optional string label = 3; + */ + java.lang.String getLabel(); + /** + * optional string label = 3; + */ + org.jetbrains.kotlin.protobuf.ByteString + getLabelBytes(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + boolean hasBody(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getBody(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop} + */ + public static final class Loop extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + loopId_ = input.readInt32(); + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = condition_.toBuilder(); + } + condition_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(condition_); + condition_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000004; + label_ = bs; + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = body_.toBuilder(); + } + body_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression condition_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + public boolean hasCondition() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getCondition() { + return condition_; + } + + public static final int LABEL_FIELD_NUMBER = 3; + private java.lang.Object label_; + /** + * optional string label = 3; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional string label = 3; + */ + public java.lang.String getLabel() { + java.lang.Object ref = label_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + label_ = s; + } + return s; + } + } + /** + * optional string label = 3; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getLabelBytes() { + java.lang.Object ref = label_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + label_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int BODY_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression body_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getBody() { + return body_; + } + + private void initFields() { + loopId_ = 0; + condition_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + label_ = ""; + body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 (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.writeBytes(3, getLabelBytes()); + } + 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 + .computeBytesSize(3, getLabelBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.LoopOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + label_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance()) return this; + if (other.hasLoopId()) { + setLoopId(other.getLoopId()); + } + if (other.hasCondition()) { + mergeCondition(other.getCondition()); + } + if (other.hasLabel()) { + bitField0_ |= 0x00000004; + label_ = other.label_; + + } + 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 (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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression condition_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + public boolean hasCondition() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getCondition() { + return condition_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + public Builder setCondition(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + condition_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + public Builder setCondition( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + condition_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + public Builder mergeCondition(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + condition_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + condition_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(condition_).mergeFrom(value).buildPartial(); + } else { + condition_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 2; + */ + public Builder clearCondition() { + condition_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private java.lang.Object label_ = ""; + /** + * optional string label = 3; + */ + public boolean hasLabel() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional string label = 3; + */ + public java.lang.String getLabel() { + java.lang.Object ref = label_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + label_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string label = 3; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getLabelBytes() { + java.lang.Object ref = label_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + label_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * optional string label = 3; + */ + public Builder setLabel( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + label_ = value; + + return this; + } + /** + * optional string label = 3; + */ + public Builder clearLabel() { + bitField0_ = (bitField0_ & ~0x00000004); + label_ = getDefaultInstance().getLabel(); + + return this; + } + /** + * optional string label = 3; + */ + public Builder setLabelBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + label_ = value; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getBody() { + return body_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + public Builder setBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + body_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + public Builder setBody( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + body_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + public Builder mergeBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + body_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + body_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(body_).mergeFrom(value).buildPartial(); + } else { + body_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression body = 4; + */ + public Builder clearBody() { + body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop) + } + + static { + defaultInstance = new Loop(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop) + } + + public interface IrReturnOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + boolean hasReturnTarget(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getReturnTarget(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + boolean hasValue(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn} + */ + public static final class IrReturn extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = returnTarget_.toBuilder(); + } + returnTarget_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(returnTarget_); + returnTarget_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol returnTarget_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + public boolean hasReturnTarget() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getReturnTarget() { + return returnTarget_; + } + + public static final int VALUE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue() { + return value_; + } + + private void initFields() { + returnTarget_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturnOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + returnTarget_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol returnTarget_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + public boolean hasReturnTarget() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getReturnTarget() { + return returnTarget_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + public Builder setReturnTarget(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + returnTarget_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + public Builder setReturnTarget( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + returnTarget_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + public Builder mergeReturnTarget(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + returnTarget_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + returnTarget_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(returnTarget_).mergeFrom(value).buildPartial(); + } else { + returnTarget_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol return_target = 1; + */ + public Builder clearReturnTarget() { + returnTarget_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue() { + return value_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder setValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder setValue( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + value_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder mergeValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + value_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + value_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder clearValue() { + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn) + } + + static { + defaultInstance = new IrReturn(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn) + } + + public interface IrSetFieldOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + boolean hasFieldAccess(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon getFieldAccess(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + boolean hasValue(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField} + */ + public static final class IrSetField extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = fieldAccess_.toBuilder(); + } + fieldAccess_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(fieldAccess_); + fieldAccess_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon fieldAccess_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public boolean hasFieldAccess() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon getFieldAccess() { + return fieldAccess_; + } + + public static final int VALUE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue() { + return value_; + } + + private void initFields() { + fieldAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance(); + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetFieldOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + fieldAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon fieldAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public boolean hasFieldAccess() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon getFieldAccess() { + return fieldAccess_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public Builder setFieldAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon value) { + if (value == null) { + throw new NullPointerException(); + } + fieldAccess_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public Builder setFieldAccess( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.Builder builderForValue) { + fieldAccess_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public Builder mergeFieldAccess(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + fieldAccess_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance()) { + fieldAccess_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.newBuilder(fieldAccess_).mergeFrom(value).buildPartial(); + } else { + fieldAccess_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.FieldAccessCommon field_access = 1; + */ + public Builder clearFieldAccess() { + fieldAccess_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.FieldAccessCommon.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue() { + return value_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder setValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder setValue( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + value_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder mergeValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + value_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + value_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder clearValue() { + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField) + } + + static { + defaultInstance = new IrSetField(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField) + } + + public interface IrSetVariableOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + boolean hasValue(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable} + */ + public static final class IrSetVariable extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int VALUE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue() { + return value_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariableOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue() { + return value_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder setValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder setValue( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + value_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder mergeValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + value_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + value_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 2; + */ + public Builder clearValue() { + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable) + } + + static { + defaultInstance = new IrSetVariable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable) + } + + public interface IrSpreadElementOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + boolean hasExpression(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + boolean hasCoordinates(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement} + */ + public static final class IrSpreadElement extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = expression_.toBuilder(); + } + expression_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(expression_); + expression_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = coordinates_.toBuilder(); + } + coordinates_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression expression_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public boolean hasExpression() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression() { + return expression_; + } + + public static final int COORDINATES_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates coordinates_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates() { + return coordinates_; + } + + private void initFields() { + expression_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElementOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + expression_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression expression_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public boolean hasExpression() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression() { + return expression_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder setExpression(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + expression_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder setExpression( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + expression_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder mergeExpression(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + expression_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + expression_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(expression_).mergeFrom(value).buildPartial(); + } else { + expression_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder clearExpression() { + expression_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates() { + return coordinates_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public Builder setCoordinates(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates value) { + if (value == null) { + throw new NullPointerException(); + } + coordinates_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public Builder setCoordinates( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.Builder builderForValue) { + coordinates_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public Builder mergeCoordinates(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + coordinates_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance()) { + coordinates_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.newBuilder(coordinates_).mergeFrom(value).buildPartial(); + } else { + coordinates_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public Builder clearCoordinates() { + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement) + } + + static { + defaultInstance = new IrSpreadElement(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement) + } + + public interface IrStringConcatOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + java.util.List + getArgumentList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getArgument(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + int getArgumentCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat} + */ + public static final class IrStringConcat extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + argument_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + argument_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public java.util.List getArgumentList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public java.util.List + getArgumentOrBuilderList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcatOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public java.util.List getArgumentList() { + return java.util.Collections.unmodifiableList(argument_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getArgument(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder setArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder addArgument(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgumentIsMutable(); + argument_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder addArgument( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder addArgument( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + ensureArgumentIsMutable(); + argument_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder clearArgument() { + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 1; + */ + public Builder removeArgument(int index) { + ensureArgumentIsMutable(); + argument_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat) + } + + static { + defaultInstance = new IrStringConcat(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat) + } + + public interface IrThrowOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + boolean hasValue(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow} + */ + public static final class IrThrow extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue() { + return value_; + } + + private void initFields() { + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrowOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getValue() { + return value_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + public Builder setValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + public Builder setValue( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + value_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + public Builder mergeValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + value_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + value_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression value = 1; + */ + public Builder clearValue() { + value_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow) + } + + static { + defaultInstance = new IrThrow(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow) + } + + public interface IrTryOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + boolean hasResult(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getResult(); + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + java.util.List + getCatchList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getCatch(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + int getCatchCount(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + boolean hasFinally(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getFinally(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry} + */ + public static final class IrTry extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = result_.toBuilder(); + } + result_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.PARSER, extensionRegistry)); + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = finally_.toBuilder(); + } + finally_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression result_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getResult() { + return result_; + } + + public static final int CATCH_FIELD_NUMBER = 2; + private java.util.List catch_; + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public java.util.List getCatchList() { + return catch_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public java.util.List + getCatchOrBuilderList() { + return catch_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public int getCatchCount() { + return catch_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getCatch(int index) { + return catch_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatementOrBuilder getCatchOrBuilder( + int index) { + return catch_.get(index); + } + + public static final int FINALLY_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression finally_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + public boolean hasFinally() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getFinally() { + return finally_; + } + + private void initFields() { + result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + catch_ = java.util.Collections.emptyList(); + finally_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTryOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + catch_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + finally_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getResult() { + return result_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + public Builder setResult(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + result_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + public Builder setResult( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + result_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + public Builder mergeResult(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + result_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + result_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(result_).mergeFrom(value).buildPartial(); + } else { + result_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 1; + */ + public Builder clearResult() { + result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public java.util.List getCatchList() { + return java.util.Collections.unmodifiableList(catch_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public int getCatchCount() { + return catch_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getCatch(int index) { + return catch_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public Builder setCatch( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureCatchIsMutable(); + catch_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public Builder setCatch( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureCatchIsMutable(); + catch_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public Builder addCatch(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureCatchIsMutable(); + catch_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public Builder addCatch( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureCatchIsMutable(); + catch_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public Builder addCatch( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureCatchIsMutable(); + catch_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public Builder addCatch( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureCatchIsMutable(); + catch_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public Builder clearCatch() { + catch_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement catch = 2; + */ + public Builder removeCatch(int index) { + ensureCatchIsMutable(); + catch_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression finally_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + public boolean hasFinally() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getFinally() { + return finally_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + public Builder setFinally(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + finally_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + public Builder setFinally( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + finally_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + public Builder mergeFinally(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + finally_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + finally_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(finally_).mergeFrom(value).buildPartial(); + } else { + finally_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression finally = 3; + */ + public Builder clearFinally() { + finally_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry) + } + + static { + defaultInstance = new IrTry(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry) + } + + public interface IrTypeOpOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOperator operator = 1; + */ + boolean hasOperator(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOperator operator = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator getOperator(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + boolean hasOperand(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getOperand(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + boolean hasArgument(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getArgument(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp} + */ + public static final class IrTypeOp extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000001; + operator_ = value; + } + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = operand_.toBuilder(); + } + operand_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(operand_); + operand_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = argument_.toBuilder(); + } + argument_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator operator_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOperator operator = 1; + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOperator operator = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator getOperator() { + return operator_; + } + + public static final int OPERAND_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex operand_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + public boolean hasOperand() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getOperand() { + return operand_; + } + + public static final int ARGUMENT_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression argument_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public boolean hasArgument() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getArgument() { + return argument_; + } + + private void initFields() { + operator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator.CAST; + operand_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + argument_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOpOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + operator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator.CAST; + bitField0_ = (bitField0_ & ~0x00000001); + operand_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + argument_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator operator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator.CAST; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOperator operator = 1; + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOperator operator = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator getOperator() { + return operator_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOperator operator = 1; + */ + public Builder setOperator(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + operator_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOperator operator = 1; + */ + public Builder clearOperator() { + bitField0_ = (bitField0_ & ~0x00000001); + operator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOperator.CAST; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex operand_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + public boolean hasOperand() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getOperand() { + return operand_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + public Builder setOperand(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + operand_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + public Builder setOperand( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + operand_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + public Builder mergeOperand(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + operand_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + operand_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(operand_).mergeFrom(value).buildPartial(); + } else { + operand_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex operand = 2; + */ + public Builder clearOperand() { + operand_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression argument_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public boolean hasArgument() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getArgument() { + return argument_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public Builder setArgument(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + argument_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public Builder setArgument( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + argument_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public Builder mergeArgument(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + argument_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + argument_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(argument_).mergeFrom(value).buildPartial(); + } else { + argument_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public Builder clearArgument() { + argument_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp) + } + + static { + defaultInstance = new IrTypeOp(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp) + } + + public interface IrVarargOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + boolean hasElementType(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getElementType(); + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + java.util.List + getElementList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement getElement(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + int getElementCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg} + */ + public static final class IrVararg extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = elementType_.toBuilder(); + } + elementType_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex elementType_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + public boolean hasElementType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getElementType() { + return elementType_; + } + + public static final int ELEMENT_FIELD_NUMBER = 2; + private java.util.List element_; + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public java.util.List getElementList() { + return element_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public java.util.List + getElementOrBuilderList() { + return element_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public int getElementCount() { + return element_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement getElement(int index) { + return element_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElementOrBuilder getElementOrBuilder( + int index) { + return element_.get(index); + } + + private void initFields() { + elementType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + elementType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex elementType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + public boolean hasElementType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getElementType() { + return elementType_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + public Builder setElementType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + elementType_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + public Builder setElementType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + elementType_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + public Builder mergeElementType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + elementType_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + elementType_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(elementType_).mergeFrom(value).buildPartial(); + } else { + elementType_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex element_type = 1; + */ + public Builder clearElementType() { + elementType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public java.util.List getElementList() { + return java.util.Collections.unmodifiableList(element_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public int getElementCount() { + return element_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement getElement(int index) { + return element_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public Builder setElement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureElementIsMutable(); + element_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public Builder setElement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement.Builder builderForValue) { + ensureElementIsMutable(); + element_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public Builder addElement(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureElementIsMutable(); + element_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public Builder addElement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureElementIsMutable(); + element_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public Builder addElement( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement.Builder builderForValue) { + ensureElementIsMutable(); + element_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public Builder addElement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement.Builder builderForValue) { + ensureElementIsMutable(); + element_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public Builder clearElement() { + element_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement element = 2; + */ + public Builder removeElement(int index) { + ensureElementIsMutable(); + element_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg) + } + + static { + defaultInstance = new IrVararg(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg) + } + + public interface IrVarargElementOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + boolean hasExpression(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + boolean hasSpreadElement(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement getSpreadElement(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement} + */ + public static final class IrVarargElement extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (varargElementCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) varargElement_).toBuilder(); + } + varargElement_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) varargElement_); + varargElement_ = subBuilder.buildPartial(); + } + varargElementCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement.Builder subBuilder = null; + if (varargElementCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement) varargElement_).toBuilder(); + } + varargElement_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public boolean hasExpression() { + return varargElementCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression() { + if (varargElementCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) varargElement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + } + + public static final int SPREAD_ELEMENT_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + public boolean hasSpreadElement() { + return varargElementCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement getSpreadElement() { + if (varargElementCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement) varargElement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) varargElement_); + } + if (varargElementCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) varargElement_); + } + if (varargElementCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElementOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVarargElement parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public boolean hasExpression() { + return varargElementCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression() { + if (varargElementCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) varargElement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder setExpression(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + varargElement_ = value; + + varargElementCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder setExpression( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + varargElement_ = builderForValue.build(); + + varargElementCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder mergeExpression(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (varargElementCase_ == 1 && + varargElement_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + varargElement_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) varargElement_) + .mergeFrom(value).buildPartial(); + } else { + varargElement_ = value; + } + + varargElementCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder clearExpression() { + if (varargElementCase_ == 1) { + varargElementCase_ = 0; + varargElement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + public boolean hasSpreadElement() { + return varargElementCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement getSpreadElement() { + if (varargElementCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement) varargElement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + public Builder setSpreadElement(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement value) { + if (value == null) { + throw new NullPointerException(); + } + varargElement_ = value; + + varargElementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + public Builder setSpreadElement( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement.Builder builderForValue) { + varargElement_ = builderForValue.build(); + + varargElementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + public Builder mergeSpreadElement(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement value) { + if (varargElementCase_ == 2 && + varargElement_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement.getDefaultInstance()) { + varargElement_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSpreadElement) varargElement_) + .mergeFrom(value).buildPartial(); + } else { + varargElement_ = value; + } + + varargElementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSpreadElement spread_element = 2; + */ + public Builder clearSpreadElement() { + if (varargElementCase_ == 2) { + varargElementCase_ = 0; + varargElement_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement) + } + + static { + defaultInstance = new IrVarargElement(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVarargElement) + } + + public interface IrWhenOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + java.util.List + getBranchList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getBranch(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + int getBranchCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen} + */ + public static final class IrWhen extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + branch_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + branch_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public java.util.List getBranchList() { + return branch_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public java.util.List + getBranchOrBuilderList() { + return branch_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public int getBranchCount() { + return branch_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getBranch(int index) { + return branch_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhenOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public java.util.List getBranchList() { + return java.util.Collections.unmodifiableList(branch_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public int getBranchCount() { + return branch_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getBranch(int index) { + return branch_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public Builder setBranch( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureBranchIsMutable(); + branch_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public Builder setBranch( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureBranchIsMutable(); + branch_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public Builder addBranch(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureBranchIsMutable(); + branch_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public Builder addBranch( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureBranchIsMutable(); + branch_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public Builder addBranch( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureBranchIsMutable(); + branch_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public Builder addBranch( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureBranchIsMutable(); + branch_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public Builder clearBranch() { + branch_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement branch = 1; + */ + public Builder removeBranch(int index) { + ensureBranchIsMutable(); + branch_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen) + } + + static { + defaultInstance = new IrWhen(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen) + } + + public interface IrWhileOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + boolean hasLoop(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop getLoop(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile} + */ + public static final class IrWhile extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = loop_.toBuilder(); + } + loop_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop loop_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public boolean hasLoop() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop getLoop() { + return loop_; + } + + private void initFields() { + loop_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhileOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + loop_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop loop_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public boolean hasLoop() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop getLoop() { + return loop_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public Builder setLoop(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop value) { + if (value == null) { + throw new NullPointerException(); + } + loop_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public Builder setLoop( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.Builder builderForValue) { + loop_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public Builder mergeLoop(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + loop_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance()) { + loop_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.newBuilder(loop_).mergeFrom(value).buildPartial(); + } else { + loop_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Loop loop = 1; + */ + public Builder clearLoop() { + loop_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Loop.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile) + } + + static { + defaultInstance = new IrWhile(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile) + } + + public interface IrOperationOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + boolean hasBlock(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock getBlock(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + boolean hasBreak(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak getBreak(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + boolean hasCall(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall getCall(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + boolean hasClassReference(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference getClassReference(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + boolean hasComposite(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite getComposite(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + boolean hasConst(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst getConst(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + boolean hasContinue(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue getContinue(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + boolean hasDelegatingConstructorCall(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall getDelegatingConstructorCall(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + boolean hasDoWhile(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile getDoWhile(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + boolean hasEnumConstructorCall(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall getEnumConstructorCall(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + boolean hasFunctionReference(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference getFunctionReference(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + boolean hasGetClass(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass getGetClass(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + boolean hasGetEnumValue(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue getGetEnumValue(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + boolean hasGetField(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField getGetField(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + boolean hasGetObject(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject getGetObject(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + boolean hasGetValue(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue getGetValue(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + boolean hasInstanceInitializerCall(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall getInstanceInitializerCall(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + boolean hasPropertyReference(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference getPropertyReference(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + boolean hasReturn(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn getReturn(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + boolean hasSetField(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField getSetField(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + boolean hasSetVariable(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable getSetVariable(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + boolean hasStringConcat(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat getStringConcat(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + boolean hasThrow(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow getThrow(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + boolean hasTry(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry getTry(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + boolean hasTypeOp(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp getTypeOp(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + boolean hasVararg(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg getVararg(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + boolean hasWhen(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen getWhen(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + boolean hasWhile(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile getWhile(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock.Builder subBuilder = null; + if (operationCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak.Builder subBuilder = null; + if (operationCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 2; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Builder subBuilder = null; + if (operationCase_ == 3) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 3; + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference.Builder subBuilder = null; + if (operationCase_ == 4) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 4; + break; + } + case 42: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite.Builder subBuilder = null; + if (operationCase_ == 5) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 5; + break; + } + case 50: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst.Builder subBuilder = null; + if (operationCase_ == 6) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 6; + break; + } + case 58: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue.Builder subBuilder = null; + if (operationCase_ == 7) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 7; + break; + } + case 66: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall.Builder subBuilder = null; + if (operationCase_ == 8) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 8; + break; + } + case 74: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile.Builder subBuilder = null; + if (operationCase_ == 9) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 9; + break; + } + case 82: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall.Builder subBuilder = null; + if (operationCase_ == 10) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 10; + break; + } + case 90: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.Builder subBuilder = null; + if (operationCase_ == 11) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 11; + break; + } + case 98: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass.Builder subBuilder = null; + if (operationCase_ == 12) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 12; + break; + } + case 106: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue.Builder subBuilder = null; + if (operationCase_ == 13) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 13; + break; + } + case 114: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField.Builder subBuilder = null; + if (operationCase_ == 14) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 14; + break; + } + case 122: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject.Builder subBuilder = null; + if (operationCase_ == 15) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 15; + break; + } + case 130: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue.Builder subBuilder = null; + if (operationCase_ == 16) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 16; + break; + } + case 138: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall.Builder subBuilder = null; + if (operationCase_ == 17) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 17; + break; + } + case 146: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference.Builder subBuilder = null; + if (operationCase_ == 18) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 18; + break; + } + case 154: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn.Builder subBuilder = null; + if (operationCase_ == 19) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 19; + break; + } + case 162: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField.Builder subBuilder = null; + if (operationCase_ == 20) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 20; + break; + } + case 170: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable.Builder subBuilder = null; + if (operationCase_ == 21) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 21; + break; + } + case 178: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat.Builder subBuilder = null; + if (operationCase_ == 22) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 22; + break; + } + case 186: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow.Builder subBuilder = null; + if (operationCase_ == 23) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 23; + break; + } + case 194: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry.Builder subBuilder = null; + if (operationCase_ == 24) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 24; + break; + } + case 202: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp.Builder subBuilder = null; + if (operationCase_ == 25) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 25; + break; + } + case 210: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg.Builder subBuilder = null; + if (operationCase_ == 26) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 26; + break; + } + case 218: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen.Builder subBuilder = null; + if (operationCase_ == 27) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 27; + break; + } + case 226: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.Builder subBuilder = null; + if (operationCase_ == 28) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 28; + 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), + 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 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.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + public boolean hasBlock() { + return operationCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock getBlock() { + if (operationCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock.getDefaultInstance(); + } + + public static final int BREAK_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + public boolean hasBreak() { + return operationCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak getBreak() { + if (operationCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak.getDefaultInstance(); + } + + public static final int CALL_FIELD_NUMBER = 3; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + public boolean hasCall() { + return operationCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall getCall() { + if (operationCase_ == 3) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.getDefaultInstance(); + } + + public static final int CLASS_REFERENCE_FIELD_NUMBER = 4; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + public boolean hasClassReference() { + return operationCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference getClassReference() { + if (operationCase_ == 4) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference.getDefaultInstance(); + } + + public static final int COMPOSITE_FIELD_NUMBER = 5; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + public boolean hasComposite() { + return operationCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite getComposite() { + if (operationCase_ == 5) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite.getDefaultInstance(); + } + + public static final int CONST_FIELD_NUMBER = 6; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + public boolean hasConst() { + return operationCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst getConst() { + if (operationCase_ == 6) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst.getDefaultInstance(); + } + + public static final int CONTINUE_FIELD_NUMBER = 7; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + public boolean hasContinue() { + return operationCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue getContinue() { + if (operationCase_ == 7) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue.getDefaultInstance(); + } + + public static final int DELEGATING_CONSTRUCTOR_CALL_FIELD_NUMBER = 8; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public boolean hasDelegatingConstructorCall() { + return operationCase_ == 8; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall getDelegatingConstructorCall() { + if (operationCase_ == 8) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall.getDefaultInstance(); + } + + public static final int DO_WHILE_FIELD_NUMBER = 9; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + public boolean hasDoWhile() { + return operationCase_ == 9; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile getDoWhile() { + if (operationCase_ == 9) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile.getDefaultInstance(); + } + + public static final int ENUM_CONSTRUCTOR_CALL_FIELD_NUMBER = 10; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + public boolean hasEnumConstructorCall() { + return operationCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall getEnumConstructorCall() { + if (operationCase_ == 10) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall.getDefaultInstance(); + } + + public static final int FUNCTION_REFERENCE_FIELD_NUMBER = 11; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + public boolean hasFunctionReference() { + return operationCase_ == 11; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference getFunctionReference() { + if (operationCase_ == 11) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.getDefaultInstance(); + } + + public static final int GET_CLASS_FIELD_NUMBER = 12; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + public boolean hasGetClass() { + return operationCase_ == 12; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass getGetClass() { + if (operationCase_ == 12) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass.getDefaultInstance(); + } + + public static final int GET_ENUM_VALUE_FIELD_NUMBER = 13; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + public boolean hasGetEnumValue() { + return operationCase_ == 13; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue getGetEnumValue() { + if (operationCase_ == 13) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue.getDefaultInstance(); + } + + public static final int GET_FIELD_FIELD_NUMBER = 14; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + public boolean hasGetField() { + return operationCase_ == 14; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField getGetField() { + if (operationCase_ == 14) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField.getDefaultInstance(); + } + + public static final int GET_OBJECT_FIELD_NUMBER = 15; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + public boolean hasGetObject() { + return operationCase_ == 15; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject getGetObject() { + if (operationCase_ == 15) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject.getDefaultInstance(); + } + + public static final int GET_VALUE_FIELD_NUMBER = 16; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + public boolean hasGetValue() { + return operationCase_ == 16; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue getGetValue() { + if (operationCase_ == 16) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue.getDefaultInstance(); + } + + public static final int INSTANCE_INITIALIZER_CALL_FIELD_NUMBER = 17; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public boolean hasInstanceInitializerCall() { + return operationCase_ == 17; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall getInstanceInitializerCall() { + if (operationCase_ == 17) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall.getDefaultInstance(); + } + + public static final int PROPERTY_REFERENCE_FIELD_NUMBER = 18; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + public boolean hasPropertyReference() { + return operationCase_ == 18; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference getPropertyReference() { + if (operationCase_ == 18) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference.getDefaultInstance(); + } + + public static final int RETURN_FIELD_NUMBER = 19; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + public boolean hasReturn() { + return operationCase_ == 19; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn getReturn() { + if (operationCase_ == 19) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn.getDefaultInstance(); + } + + public static final int SET_FIELD_FIELD_NUMBER = 20; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + public boolean hasSetField() { + return operationCase_ == 20; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField getSetField() { + if (operationCase_ == 20) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField.getDefaultInstance(); + } + + public static final int SET_VARIABLE_FIELD_NUMBER = 21; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + public boolean hasSetVariable() { + return operationCase_ == 21; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable getSetVariable() { + if (operationCase_ == 21) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable.getDefaultInstance(); + } + + public static final int STRING_CONCAT_FIELD_NUMBER = 22; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + public boolean hasStringConcat() { + return operationCase_ == 22; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat getStringConcat() { + if (operationCase_ == 22) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat.getDefaultInstance(); + } + + public static final int THROW_FIELD_NUMBER = 23; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + public boolean hasThrow() { + return operationCase_ == 23; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow getThrow() { + if (operationCase_ == 23) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow.getDefaultInstance(); + } + + public static final int TRY_FIELD_NUMBER = 24; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + public boolean hasTry() { + return operationCase_ == 24; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry getTry() { + if (operationCase_ == 24) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry.getDefaultInstance(); + } + + public static final int TYPE_OP_FIELD_NUMBER = 25; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + public boolean hasTypeOp() { + return operationCase_ == 25; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp getTypeOp() { + if (operationCase_ == 25) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp.getDefaultInstance(); + } + + public static final int VARARG_FIELD_NUMBER = 26; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + public boolean hasVararg() { + return operationCase_ == 26; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg getVararg() { + if (operationCase_ == 26) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg.getDefaultInstance(); + } + + public static final int WHEN_FIELD_NUMBER = 27; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + public boolean hasWhen() { + return operationCase_ == 27; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen getWhen() { + if (operationCase_ == 27) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen.getDefaultInstance(); + } + + public static final int WHILE_FIELD_NUMBER = 28; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + public boolean hasWhile() { + return operationCase_ == 28; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile getWhile() { + if (operationCase_ == 28) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.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 (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; + } + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock) operation_); + } + if (operationCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak) operation_); + } + if (operationCase_ == 3) { + output.writeMessage(3, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall) operation_); + } + if (operationCase_ == 4) { + output.writeMessage(4, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference) operation_); + } + if (operationCase_ == 5) { + output.writeMessage(5, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite) operation_); + } + if (operationCase_ == 6) { + output.writeMessage(6, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst) operation_); + } + if (operationCase_ == 7) { + output.writeMessage(7, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue) operation_); + } + if (operationCase_ == 8) { + output.writeMessage(8, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall) operation_); + } + if (operationCase_ == 9) { + output.writeMessage(9, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile) operation_); + } + if (operationCase_ == 10) { + output.writeMessage(10, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall) operation_); + } + if (operationCase_ == 11) { + output.writeMessage(11, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference) operation_); + } + if (operationCase_ == 12) { + output.writeMessage(12, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass) operation_); + } + if (operationCase_ == 13) { + output.writeMessage(13, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue) operation_); + } + if (operationCase_ == 14) { + output.writeMessage(14, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField) operation_); + } + if (operationCase_ == 15) { + output.writeMessage(15, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject) operation_); + } + if (operationCase_ == 16) { + output.writeMessage(16, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue) operation_); + } + if (operationCase_ == 17) { + output.writeMessage(17, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall) operation_); + } + if (operationCase_ == 18) { + output.writeMessage(18, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference) operation_); + } + if (operationCase_ == 19) { + output.writeMessage(19, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn) operation_); + } + if (operationCase_ == 20) { + output.writeMessage(20, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField) operation_); + } + if (operationCase_ == 21) { + output.writeMessage(21, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable) operation_); + } + if (operationCase_ == 22) { + output.writeMessage(22, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat) operation_); + } + if (operationCase_ == 23) { + output.writeMessage(23, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow) operation_); + } + if (operationCase_ == 24) { + output.writeMessage(24, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry) operation_); + } + if (operationCase_ == 25) { + output.writeMessage(25, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp) operation_); + } + if (operationCase_ == 26) { + output.writeMessage(26, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg) operation_); + } + if (operationCase_ == 27) { + output.writeMessage(27, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen) operation_); + } + if (operationCase_ == 28) { + output.writeMessage(28, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock) operation_); + } + if (operationCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak) operation_); + } + if (operationCase_ == 3) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall) operation_); + } + if (operationCase_ == 4) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference) operation_); + } + if (operationCase_ == 5) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite) operation_); + } + if (operationCase_ == 6) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(6, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst) operation_); + } + if (operationCase_ == 7) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(7, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue) operation_); + } + if (operationCase_ == 8) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(8, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall) operation_); + } + if (operationCase_ == 9) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(9, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile) operation_); + } + if (operationCase_ == 10) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(10, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall) operation_); + } + if (operationCase_ == 11) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(11, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference) operation_); + } + if (operationCase_ == 12) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(12, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass) operation_); + } + if (operationCase_ == 13) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(13, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue) operation_); + } + if (operationCase_ == 14) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(14, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField) operation_); + } + if (operationCase_ == 15) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(15, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject) operation_); + } + if (operationCase_ == 16) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(16, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue) operation_); + } + if (operationCase_ == 17) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(17, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall) operation_); + } + if (operationCase_ == 18) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(18, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference) operation_); + } + if (operationCase_ == 19) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(19, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn) operation_); + } + if (operationCase_ == 20) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(20, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField) operation_); + } + if (operationCase_ == 21) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(21, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable) operation_); + } + if (operationCase_ == 22) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(22, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat) operation_); + } + if (operationCase_ == 23) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(23, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow) operation_); + } + if (operationCase_ == 24) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(24, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry) operation_); + } + if (operationCase_ == 25) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(25, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp) operation_); + } + if (operationCase_ == 26) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(26, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg) operation_); + } + if (operationCase_ == 27) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(27, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen) operation_); + } + if (operationCase_ == 28) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(28, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperationOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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_; + } + result.bitField0_ = to_bitField0_; + result.operationCase_ = operationCase_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 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 (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; + } + } + return true; + } + + public Builder mergeFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + public boolean hasBlock() { + return operationCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock getBlock() { + if (operationCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + public Builder setBlock(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + public Builder setBlock( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + public Builder mergeBlock(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock value) { + if (operationCase_ == 1 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlock) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlock block = 1; + */ + public Builder clearBlock() { + if (operationCase_ == 1) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + public boolean hasBreak() { + return operationCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak getBreak() { + if (operationCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + public Builder setBreak(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + public Builder setBreak( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + public Builder mergeBreak(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak value) { + if (operationCase_ == 2 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBreak) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBreak break = 2; + */ + public Builder clearBreak() { + if (operationCase_ == 2) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + public boolean hasCall() { + return operationCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall getCall() { + if (operationCase_ == 3) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + public Builder setCall(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + public Builder setCall( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + public Builder mergeCall(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall value) { + if (operationCase_ == 3 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCall) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCall call = 3; + */ + public Builder clearCall() { + if (operationCase_ == 3) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + public boolean hasClassReference() { + return operationCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference getClassReference() { + if (operationCase_ == 4) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + public Builder setClassReference(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + public Builder setClassReference( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + public Builder mergeClassReference(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference value) { + if (operationCase_ == 4 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassReference) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClassReference class_reference = 4; + */ + public Builder clearClassReference() { + if (operationCase_ == 4) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + public boolean hasComposite() { + return operationCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite getComposite() { + if (operationCase_ == 5) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + public Builder setComposite(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + public Builder setComposite( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + public Builder mergeComposite(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite value) { + if (operationCase_ == 5 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrComposite) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrComposite composite = 5; + */ + public Builder clearComposite() { + if (operationCase_ == 5) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + public boolean hasConst() { + return operationCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst getConst() { + if (operationCase_ == 6) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + public Builder setConst(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + public Builder setConst( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + public Builder mergeConst(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst value) { + if (operationCase_ == 6 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConst) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConst const = 6; + */ + public Builder clearConst() { + if (operationCase_ == 6) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + public boolean hasContinue() { + return operationCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue getContinue() { + if (operationCase_ == 7) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + public Builder setContinue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + public Builder setContinue( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + public Builder mergeContinue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue value) { + if (operationCase_ == 7 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrContinue) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrContinue continue = 7; + */ + public Builder clearContinue() { + if (operationCase_ == 7) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public boolean hasDelegatingConstructorCall() { + return operationCase_ == 8; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall getDelegatingConstructorCall() { + if (operationCase_ == 8) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public Builder setDelegatingConstructorCall(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public Builder setDelegatingConstructorCall( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public Builder mergeDelegatingConstructorCall(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall value) { + if (operationCase_ == 8 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDelegatingConstructorCall) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDelegatingConstructorCall delegating_constructor_call = 8; + */ + public Builder clearDelegatingConstructorCall() { + if (operationCase_ == 8) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + public boolean hasDoWhile() { + return operationCase_ == 9; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile getDoWhile() { + if (operationCase_ == 9) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + public Builder setDoWhile(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + public Builder setDoWhile( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + public Builder mergeDoWhile(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile value) { + if (operationCase_ == 9 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDoWhile) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDoWhile do_while = 9; + */ + public Builder clearDoWhile() { + if (operationCase_ == 9) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + public boolean hasEnumConstructorCall() { + return operationCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall getEnumConstructorCall() { + if (operationCase_ == 10) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + public Builder setEnumConstructorCall(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + public Builder setEnumConstructorCall( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + public Builder mergeEnumConstructorCall(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall value) { + if (operationCase_ == 10 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumConstructorCall) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumConstructorCall enum_constructor_call = 10; + */ + public Builder clearEnumConstructorCall() { + if (operationCase_ == 10) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + public boolean hasFunctionReference() { + return operationCase_ == 11; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference getFunctionReference() { + if (operationCase_ == 11) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + public Builder setFunctionReference(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + public Builder setFunctionReference( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + public Builder mergeFunctionReference(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference value) { + if (operationCase_ == 11 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionReference) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionReference function_reference = 11; + */ + public Builder clearFunctionReference() { + if (operationCase_ == 11) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + public boolean hasGetClass() { + return operationCase_ == 12; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass getGetClass() { + if (operationCase_ == 12) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + public Builder setGetClass(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 12; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + public Builder setGetClass( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 12; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + public Builder mergeGetClass(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass value) { + if (operationCase_ == 12 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetClass) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 12; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetClass get_class = 12; + */ + public Builder clearGetClass() { + if (operationCase_ == 12) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + public boolean hasGetEnumValue() { + return operationCase_ == 13; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue getGetEnumValue() { + if (operationCase_ == 13) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + public Builder setGetEnumValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 13; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + public Builder setGetEnumValue( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 13; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + public Builder mergeGetEnumValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue value) { + if (operationCase_ == 13 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetEnumValue) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 13; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetEnumValue get_enum_value = 13; + */ + public Builder clearGetEnumValue() { + if (operationCase_ == 13) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + public boolean hasGetField() { + return operationCase_ == 14; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField getGetField() { + if (operationCase_ == 14) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + public Builder setGetField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 14; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + public Builder setGetField( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 14; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + public Builder mergeGetField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField value) { + if (operationCase_ == 14 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetField) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 14; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetField get_field = 14; + */ + public Builder clearGetField() { + if (operationCase_ == 14) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + public boolean hasGetObject() { + return operationCase_ == 15; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject getGetObject() { + if (operationCase_ == 15) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + public Builder setGetObject(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 15; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + public Builder setGetObject( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 15; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + public Builder mergeGetObject(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject value) { + if (operationCase_ == 15 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetObject) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 15; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetObject get_object = 15; + */ + public Builder clearGetObject() { + if (operationCase_ == 15) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + public boolean hasGetValue() { + return operationCase_ == 16; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue getGetValue() { + if (operationCase_ == 16) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + public Builder setGetValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 16; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + public Builder setGetValue( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 16; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + public Builder mergeGetValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue value) { + if (operationCase_ == 16 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrGetValue) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 16; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrGetValue get_value = 16; + */ + public Builder clearGetValue() { + if (operationCase_ == 16) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public boolean hasInstanceInitializerCall() { + return operationCase_ == 17; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall getInstanceInitializerCall() { + if (operationCase_ == 17) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public Builder setInstanceInitializerCall(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 17; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public Builder setInstanceInitializerCall( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 17; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public Builder mergeInstanceInitializerCall(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall value) { + if (operationCase_ == 17 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrInstanceInitializerCall) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 17; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrInstanceInitializerCall instance_initializer_call = 17; + */ + public Builder clearInstanceInitializerCall() { + if (operationCase_ == 17) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + public boolean hasPropertyReference() { + return operationCase_ == 18; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference getPropertyReference() { + if (operationCase_ == 18) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + public Builder setPropertyReference(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 18; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + public Builder setPropertyReference( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 18; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + public Builder mergePropertyReference(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference value) { + if (operationCase_ == 18 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyReference) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 18; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrPropertyReference property_reference = 18; + */ + public Builder clearPropertyReference() { + if (operationCase_ == 18) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + public boolean hasReturn() { + return operationCase_ == 19; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn getReturn() { + if (operationCase_ == 19) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + public Builder setReturn(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 19; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + public Builder setReturn( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 19; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + public Builder mergeReturn(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn value) { + if (operationCase_ == 19 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrReturn) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 19; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrReturn return = 19; + */ + public Builder clearReturn() { + if (operationCase_ == 19) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + public boolean hasSetField() { + return operationCase_ == 20; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField getSetField() { + if (operationCase_ == 20) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + public Builder setSetField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 20; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + public Builder setSetField( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 20; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + public Builder mergeSetField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField value) { + if (operationCase_ == 20 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetField) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 20; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetField set_field = 20; + */ + public Builder clearSetField() { + if (operationCase_ == 20) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + public boolean hasSetVariable() { + return operationCase_ == 21; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable getSetVariable() { + if (operationCase_ == 21) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + public Builder setSetVariable(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 21; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + public Builder setSetVariable( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 21; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + public Builder mergeSetVariable(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable value) { + if (operationCase_ == 21 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSetVariable) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 21; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSetVariable set_variable = 21; + */ + public Builder clearSetVariable() { + if (operationCase_ == 21) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + public boolean hasStringConcat() { + return operationCase_ == 22; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat getStringConcat() { + if (operationCase_ == 22) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + public Builder setStringConcat(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 22; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + public Builder setStringConcat( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 22; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + public Builder mergeStringConcat(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat value) { + if (operationCase_ == 22 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStringConcat) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 22; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStringConcat string_concat = 22; + */ + public Builder clearStringConcat() { + if (operationCase_ == 22) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + public boolean hasThrow() { + return operationCase_ == 23; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow getThrow() { + if (operationCase_ == 23) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + public Builder setThrow(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 23; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + public Builder setThrow( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 23; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + public Builder mergeThrow(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow value) { + if (operationCase_ == 23 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrThrow) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 23; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrThrow throw = 23; + */ + public Builder clearThrow() { + if (operationCase_ == 23) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + public boolean hasTry() { + return operationCase_ == 24; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry getTry() { + if (operationCase_ == 24) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + public Builder setTry(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 24; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + public Builder setTry( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 24; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + public Builder mergeTry(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry value) { + if (operationCase_ == 24 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTry) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 24; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTry try = 24; + */ + public Builder clearTry() { + if (operationCase_ == 24) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + public boolean hasTypeOp() { + return operationCase_ == 25; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp getTypeOp() { + if (operationCase_ == 25) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + public Builder setTypeOp(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 25; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + public Builder setTypeOp( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 25; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + public Builder mergeTypeOp(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp value) { + if (operationCase_ == 25 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeOp) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 25; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeOp type_op = 25; + */ + public Builder clearTypeOp() { + if (operationCase_ == 25) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + public boolean hasVararg() { + return operationCase_ == 26; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg getVararg() { + if (operationCase_ == 26) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + public Builder setVararg(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 26; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + public Builder setVararg( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 26; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + public Builder mergeVararg(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg value) { + if (operationCase_ == 26 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVararg) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 26; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVararg vararg = 26; + */ + public Builder clearVararg() { + if (operationCase_ == 26) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + public boolean hasWhen() { + return operationCase_ == 27; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen getWhen() { + if (operationCase_ == 27) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + public Builder setWhen(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 27; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + public Builder setWhen( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 27; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + public Builder mergeWhen(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen value) { + if (operationCase_ == 27 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhen) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 27; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhen when = 27; + */ + public Builder clearWhen() { + if (operationCase_ == 27) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + public boolean hasWhile() { + return operationCase_ == 28; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile getWhile() { + if (operationCase_ == 28) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + public Builder setWhile(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 28; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + public Builder setWhile( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 28; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + public Builder mergeWhile(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile value) { + if (operationCase_ == 28 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 28; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile while = 28; + */ + public Builder clearWhile() { + if (operationCase_ == 28) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation) + } + + static { + defaultInstance = new IrOperation(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation) + } + + public interface IrExpressionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + boolean hasOperation(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation getOperation(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + boolean hasCoordinates(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression} + */ + public static final class IrExpression extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = operation_.toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(operation_); + operation_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(type_); + type_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = coordinates_.toBuilder(); + } + coordinates_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation operation_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + public boolean hasOperation() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation getOperation() { + return operation_; + } + + public static final int TYPE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType() { + return type_; + } + + public static final int COORDINATES_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates coordinates_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates() { + return coordinates_; + } + + private void initFields() { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.getDefaultInstance(); + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpressionOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + public boolean hasOperation() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation getOperation() { + return operation_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + public Builder setOperation(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + public Builder setOperation( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.Builder builderForValue) { + operation_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + public Builder mergeOperation(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.getDefaultInstance()) { + operation_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.newBuilder(operation_).mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation operation = 1; + */ + public Builder clearOperation() { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrOperation.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public Builder setType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public Builder setType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public Builder mergeType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + type_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 2; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates() { + return coordinates_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + public Builder setCoordinates(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates value) { + if (value == null) { + throw new NullPointerException(); + } + coordinates_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + public Builder setCoordinates( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.Builder builderForValue) { + coordinates_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + public Builder mergeCoordinates(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + coordinates_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance()) { + coordinates_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.newBuilder(coordinates_).mergeFrom(value).buildPartial(); + } else { + coordinates_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 3; + */ + public Builder clearCoordinates() { + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression) + } + + static { + defaultInstance = new IrExpression(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression) + } + + public interface NullableIrExpressionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + boolean hasExpression(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression} + */ + public static final class NullableIrExpression extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = expression_.toBuilder(); + } + expression_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression expression_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public boolean hasExpression() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression() { + return expression_; + } + + private void initFields() { + expression_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpressionOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + expression_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.NullableIrExpression) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression expression_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public boolean hasExpression() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression() { + return expression_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder setExpression(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + expression_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder setExpression( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + expression_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder mergeExpression(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + expression_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + expression_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(expression_).mergeFrom(value).buildPartial(); + } else { + expression_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 1; + */ + public Builder clearExpression() { + expression_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression) + } + + static { + defaultInstance = new NullableIrExpression(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.NullableIrExpression) + } + + public interface IrTypeAliasOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias} + * + * 
+   * Nothing for now.
+   *
+ */ + public static final class IrTypeAlias extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias} + * + * 
+     * Nothing for now.
+     *
+ */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAliasOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias(this); + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias) + } + + static { + defaultInstance = new IrTypeAlias(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias) + } + + public interface IrFunctionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + boolean hasBase(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase getBase(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 3; + */ + boolean hasModality(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + java.util.List + getOverriddenList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getOverridden(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + int getOverriddenCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction} + */ + public static final class IrFunction extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = base_.toBuilder(); + } + base_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(base_); + base_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 24: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int BASE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase base_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public boolean hasBase() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase getBase() { + return base_; + } + + public static final int MODALITY_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind modality_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 3; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public java.util.List getOverriddenList() { + return overridden_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public java.util.List + getOverriddenOrBuilderList() { + return overridden_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public int getOverriddenCount() { + return overridden_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getOverridden(int index) { + return overridden_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+     *optional UniqId corresponding_property = 7;
+     *
+ */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbolOrBuilder getOverriddenOrBuilder( + int index) { + return overridden_.get(index); + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + base_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance(); + modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + base_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase base_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public boolean hasBase() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase getBase() { + return base_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public Builder setBase(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase value) { + if (value == null) { + throw new NullPointerException(); + } + base_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public Builder setBase( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.Builder builderForValue) { + base_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public Builder mergeBase(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + base_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance()) { + base_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.newBuilder(base_).mergeFrom(value).buildPartial(); + } else { + base_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public Builder clearBase() { + base_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind.FINAL_MODALITY; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 3; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind getModality() { + return modality_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 3; + */ + public Builder setModality(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + modality_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 3; + */ + public Builder clearModality() { + bitField0_ = (bitField0_ & ~0x00000004); + modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public java.util.List getOverriddenList() { + return java.util.Collections.unmodifiableList(overridden_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public int getOverriddenCount() { + return overridden_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getOverridden(int index) { + return overridden_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder setOverridden( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + ensureOverriddenIsMutable(); + overridden_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder setOverridden( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + ensureOverriddenIsMutable(); + overridden_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder addOverridden(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + ensureOverriddenIsMutable(); + overridden_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder addOverridden( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + ensureOverriddenIsMutable(); + overridden_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder addOverridden( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + ensureOverriddenIsMutable(); + overridden_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol overridden = 6; + * + * 
+       *optional UniqId corresponding_property = 7;
+       *
+ */ + public Builder addOverridden( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + ensureOverriddenIsMutable(); + overridden_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrFunction) + } + + static { + defaultInstance = new IrFunction(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction) + } + + public interface IrFunctionBaseOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required string name = 1; + */ + boolean hasName(); + /** + * required string name = 1; + */ + java.lang.String getName(); + /** + * required string name = 1; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + + /** + * required string visibility = 2; + */ + boolean hasVisibility(); + /** + * required string visibility = 2; + */ + java.lang.String getVisibility(); + /** + * required string visibility = 2; + */ + org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes(); + + /** + * 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.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + boolean hasTypeParameters(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer getTypeParameters(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + boolean hasDispatchReceiver(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDispatchReceiver(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + boolean hasExtensionReceiver(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getExtensionReceiver(); + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + java.util.List + getValueParameterList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getValueParameter(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + int getValueParameterCount(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + boolean hasBody(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getBody(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + boolean hasReturnType(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getReturnType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase} + */ + public static final class IrFunctionBase extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = bs; + break; + } + case 18: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + visibility_ = bs; + break; + } + case 24: { + bitField0_ |= 0x00000004; + isInline_ = input.readBool(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + isExternal_ = input.readBool(); + break; + } + case 42: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = typeParameters_.toBuilder(); + } + typeParameters_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(typeParameters_); + typeParameters_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + case 50: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000020) == 0x00000020)) { + subBuilder = dispatchReceiver_.toBuilder(); + } + dispatchReceiver_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(dispatchReceiver_); + dispatchReceiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000020; + break; + } + case 58: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000040) == 0x00000040)) { + subBuilder = extensionReceiver_.toBuilder(); + } + extensionReceiver_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.PARSER, extensionRegistry)); + break; + } + case 74: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + subBuilder = body_.toBuilder(); + } + body_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(body_); + body_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000080; + break; + } + case 82: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000100) == 0x00000100)) { + subBuilder = returnType_.toBuilder(); + } + returnType_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 java.lang.Object name_; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int VISIBILITY_FIELD_NUMBER = 2; + private java.lang.Object visibility_; + /** + * required string visibility = 2; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string visibility = 2; + */ + public java.lang.String getVisibility() { + java.lang.Object ref = visibility_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + visibility_ = s; + } + return s; + } + } + /** + * required string visibility = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes() { + java.lang.Object ref = visibility_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + visibility_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer typeParameters_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + public boolean hasTypeParameters() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer getTypeParameters() { + return typeParameters_; + } + + public static final int DISPATCH_RECEIVER_FIELD_NUMBER = 6; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration dispatchReceiver_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + public boolean hasDispatchReceiver() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDispatchReceiver() { + return dispatchReceiver_; + } + + public static final int EXTENSION_RECEIVER_FIELD_NUMBER = 7; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration extensionReceiver_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + public boolean hasExtensionReceiver() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getExtensionReceiver() { + return extensionReceiver_; + } + + public static final int VALUE_PARAMETER_FIELD_NUMBER = 8; + private java.util.List valueParameter_; + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public java.util.List getValueParameterList() { + return valueParameter_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public java.util.List + getValueParameterOrBuilderList() { + return valueParameter_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public int getValueParameterCount() { + return valueParameter_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getValueParameter(int index) { + return valueParameter_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrBuilder getValueParameterOrBuilder( + int index) { + return valueParameter_.get(index); + } + + public static final int BODY_FIELD_NUMBER = 9; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement body_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getBody() { + return body_; + } + + public static final int RETURN_TYPE_FIELD_NUMBER = 10; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex returnType_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + public boolean hasReturnType() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getReturnType() { + return returnType_; + } + + private void initFields() { + name_ = ""; + visibility_ = ""; + isInline_ = false; + isExternal_ = false; + typeParameters_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance(); + dispatchReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + extensionReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + valueParameter_ = java.util.Collections.emptyList(); + body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance(); + returnType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 (!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.writeBytes(1, getNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getVisibilityBytes()); + } + 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 + .computeBytesSize(1, getNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBytesSize(2, getVisibilityBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBaseOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + visibility_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + isInline_ = false; + bitField0_ = (bitField0_ & ~0x00000004); + isExternal_ = false; + bitField0_ = (bitField0_ & ~0x00000008); + typeParameters_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); + dispatchReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000020); + extensionReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000040); + valueParameter_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000100); + returnType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000200); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + + } + if (other.hasVisibility()) { + bitField0_ |= 0x00000002; + visibility_ = other.visibility_; + + } + 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 (!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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 1; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + /** + * required string name = 1; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 1; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + + private java.lang.Object visibility_ = ""; + /** + * required string visibility = 2; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string visibility = 2; + */ + public java.lang.String getVisibility() { + java.lang.Object ref = visibility_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + visibility_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string visibility = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes() { + java.lang.Object ref = visibility_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + visibility_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string visibility = 2; + */ + public Builder setVisibility( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + visibility_ = value; + + return this; + } + /** + * required string visibility = 2; + */ + public Builder clearVisibility() { + bitField0_ = (bitField0_ & ~0x00000002); + visibility_ = getDefaultInstance().getVisibility(); + + return this; + } + /** + * required string visibility = 2; + */ + public Builder setVisibilityBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + visibility_ = value; + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer typeParameters_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + public boolean hasTypeParameters() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer getTypeParameters() { + return typeParameters_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + public Builder setTypeParameters(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer value) { + if (value == null) { + throw new NullPointerException(); + } + typeParameters_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + public Builder setTypeParameters( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.Builder builderForValue) { + typeParameters_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + public Builder mergeTypeParameters(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + typeParameters_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance()) { + typeParameters_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.newBuilder(typeParameters_).mergeFrom(value).buildPartial(); + } else { + typeParameters_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 5; + */ + public Builder clearTypeParameters() { + typeParameters_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration dispatchReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + public boolean hasDispatchReceiver() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDispatchReceiver() { + return dispatchReceiver_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + public Builder setDispatchReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + dispatchReceiver_ = value; + + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + public Builder setDispatchReceiver( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + dispatchReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + public Builder mergeDispatchReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (((bitField0_ & 0x00000020) == 0x00000020) && + dispatchReceiver_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance()) { + dispatchReceiver_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.newBuilder(dispatchReceiver_).mergeFrom(value).buildPartial(); + } else { + dispatchReceiver_ = value; + } + + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration dispatch_receiver = 6; + */ + public Builder clearDispatchReceiver() { + dispatchReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration extensionReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + public boolean hasExtensionReceiver() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getExtensionReceiver() { + return extensionReceiver_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + public Builder setExtensionReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + extensionReceiver_ = value; + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + public Builder setExtensionReceiver( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + extensionReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + public Builder mergeExtensionReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (((bitField0_ & 0x00000040) == 0x00000040) && + extensionReceiver_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance()) { + extensionReceiver_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.newBuilder(extensionReceiver_).mergeFrom(value).buildPartial(); + } else { + extensionReceiver_ = value; + } + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration extension_receiver = 7; + */ + public Builder clearExtensionReceiver() { + extensionReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public java.util.List getValueParameterList() { + return java.util.Collections.unmodifiableList(valueParameter_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public int getValueParameterCount() { + return valueParameter_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getValueParameter(int index) { + return valueParameter_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public Builder setValueParameter( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueParameterIsMutable(); + valueParameter_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public Builder setValueParameter( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + ensureValueParameterIsMutable(); + valueParameter_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public Builder addValueParameter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueParameterIsMutable(); + valueParameter_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public Builder addValueParameter( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueParameterIsMutable(); + valueParameter_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public Builder addValueParameter( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + ensureValueParameterIsMutable(); + valueParameter_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public Builder addValueParameter( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + ensureValueParameterIsMutable(); + valueParameter_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public Builder clearValueParameter() { + valueParameter_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration value_parameter = 8; + */ + public Builder removeValueParameter(int index) { + ensureValueParameterIsMutable(); + valueParameter_.remove(index); + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getBody() { + return body_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + public Builder setBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + body_ = value; + + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + public Builder setBody( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + body_ = builderForValue.build(); + + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + public Builder mergeBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (((bitField0_ & 0x00000100) == 0x00000100) && + body_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance()) { + body_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.newBuilder(body_).mergeFrom(value).buildPartial(); + } else { + body_ = value; + } + + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 9; + */ + public Builder clearBody() { + body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000100); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex returnType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + public boolean hasReturnType() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getReturnType() { + return returnType_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + public Builder setReturnType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + returnType_ = value; + + bitField0_ |= 0x00000200; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + public Builder setReturnType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + returnType_ = builderForValue.build(); + + bitField0_ |= 0x00000200; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + public Builder mergeReturnType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000200) == 0x00000200) && + returnType_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + returnType_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(returnType_).mergeFrom(value).buildPartial(); + } else { + returnType_ = value; + } + + bitField0_ |= 0x00000200; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex return_type = 10; + */ + public Builder clearReturnType() { + returnType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000200); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase) + } + + static { + defaultInstance = new IrFunctionBase(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase) + } + + public interface IrConstructorOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + boolean hasBase(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase getBase(); + + /** + * required bool is_primary = 3; + */ + boolean hasIsPrimary(); + /** + * required bool is_primary = 3; + */ + boolean getIsPrimary(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor} + */ + public static final class IrConstructor extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = base_.toBuilder(); + } + base_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int BASE_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase base_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public boolean hasBase() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + base_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructorOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + base_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + isPrimary_ = false; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase base_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public boolean hasBase() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase getBase() { + return base_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public Builder setBase(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase value) { + if (value == null) { + throw new NullPointerException(); + } + base_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public Builder setBase( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.Builder builderForValue) { + base_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public Builder mergeBase(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + base_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.getDefaultInstance()) { + base_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunctionBase.newBuilder(base_).mergeFrom(value).buildPartial(); + } else { + base_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunctionBase base = 2; + */ + public Builder clearBase() { + base_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrConstructor) + } + + static { + defaultInstance = new IrConstructor(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor) + } + + public interface IrFieldOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + boolean hasInitializer(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getInitializer(); + + /** + * required string name = 3; + */ + boolean hasName(); + /** + * required string name = 3; + */ + java.lang.String getName(); + /** + * required string name = 3; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + + /** + * required string visibility = 4; + */ + boolean hasVisibility(); + /** + * required string visibility = 4; + */ + java.lang.String getVisibility(); + /** + * required string visibility = 4; + */ + org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes(); + + /** + * 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.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField} + */ + public static final class IrField extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = initializer_.toBuilder(); + } + initializer_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(initializer_); + initializer_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000004; + name_ = bs; + break; + } + case 34: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000008; + visibility_ = bs; + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int INITIALIZER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression initializer_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getInitializer() { + return initializer_; + } + + public static final int NAME_FIELD_NUMBER = 3; + private java.lang.Object name_; + /** + * required string name = 3; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string name = 3; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 3; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int VISIBILITY_FIELD_NUMBER = 4; + private java.lang.Object visibility_; + /** + * required string visibility = 4; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required string visibility = 4; + */ + public java.lang.String getVisibility() { + java.lang.Object ref = visibility_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + visibility_ = s; + } + return s; + } + } + /** + * required string visibility = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes() { + java.lang.Object ref = visibility_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + visibility_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType() { + return type_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + name_ = ""; + visibility_ = ""; + isFinal_ = false; + isExternal_ = false; + isStatic_ = false; + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 (!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.writeBytes(3, getNameBytes()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeBytes(4, getVisibilityBytes()); + } + 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 + .computeBytesSize(3, getNameBytes()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBytesSize(4, getVisibilityBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFieldOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + visibility_ = ""; + bitField0_ = (bitField0_ & ~0x00000008); + isFinal_ = false; + bitField0_ = (bitField0_ & ~0x00000010); + isExternal_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + isStatic_ = false; + bitField0_ = (bitField0_ & ~0x00000040); + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasInitializer()) { + mergeInitializer(other.getInitializer()); + } + if (other.hasName()) { + bitField0_ |= 0x00000004; + name_ = other.name_; + + } + if (other.hasVisibility()) { + bitField0_ |= 0x00000008; + visibility_ = other.visibility_; + + } + 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 (!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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getInitializer() { + return initializer_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public Builder setInitializer(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + initializer_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public Builder setInitializer( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + initializer_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public Builder mergeInitializer(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + initializer_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + initializer_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(initializer_).mergeFrom(value).buildPartial(); + } else { + initializer_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public Builder clearInitializer() { + initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private java.lang.Object name_ = ""; + /** + * required string name = 3; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string name = 3; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 3; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 3; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + name_ = value; + + return this; + } + /** + * required string name = 3; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000004); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 3; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + name_ = value; + + return this; + } + + private java.lang.Object visibility_ = ""; + /** + * required string visibility = 4; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required string visibility = 4; + */ + public java.lang.String getVisibility() { + java.lang.Object ref = visibility_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + visibility_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string visibility = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes() { + java.lang.Object ref = visibility_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + visibility_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string visibility = 4; + */ + public Builder setVisibility( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + visibility_ = value; + + return this; + } + /** + * required string visibility = 4; + */ + public Builder clearVisibility() { + bitField0_ = (bitField0_ & ~0x00000008); + visibility_ = getDefaultInstance().getVisibility(); + + return this; + } + /** + * required string visibility = 4; + */ + public Builder setVisibilityBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + visibility_ = value; + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + public Builder setType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000080; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + public Builder setType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000080; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + public Builder mergeType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000080) == 0x00000080) && + type_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000080; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 8; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField) + } + + static { + defaultInstance = new IrField(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField) + } + + public interface IrPropertyOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + boolean hasDescriptor(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference getDescriptor(); + + /** + * required string name = 2; + */ + boolean hasName(); + /** + * required string name = 2; + */ + java.lang.String getName(); + /** + * required string name = 2; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + + /** + * required string visibility = 3; + */ + boolean hasVisibility(); + /** + * required string visibility = 3; + */ + java.lang.String getVisibility(); + /** + * required string visibility = 3; + */ + org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 4; + */ + boolean hasModality(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + boolean hasBackingField(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField getBackingField(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + boolean hasGetter(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getGetter(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + boolean hasSetter(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getSetter(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty} + */ + public static final class IrProperty extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = descriptor_.toBuilder(); + } + descriptor_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(descriptor_); + descriptor_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + name_ = bs; + break; + } + case 26: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000004; + visibility_ = bs; + break; + } + case 32: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.Builder subBuilder = null; + if (((bitField0_ & 0x00000200) == 0x00000200)) { + subBuilder = backingField_.toBuilder(); + } + backingField_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(backingField_); + backingField_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000200; + break; + } + case 90: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.Builder subBuilder = null; + if (((bitField0_ & 0x00000400) == 0x00000400)) { + subBuilder = getter_.toBuilder(); + } + getter_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(getter_); + getter_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000400; + break; + } + case 98: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.Builder subBuilder = null; + if (((bitField0_ & 0x00000800) == 0x00000800)) { + subBuilder = setter_.toBuilder(); + } + setter_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference descriptor_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + public boolean hasDescriptor() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+     * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+     *
+ */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference getDescriptor() { + return descriptor_; + } + + public static final int NAME_FIELD_NUMBER = 2; + private java.lang.Object name_; + /** + * required string name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int VISIBILITY_FIELD_NUMBER = 3; + private java.lang.Object visibility_; + /** + * required string visibility = 3; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string visibility = 3; + */ + public java.lang.String getVisibility() { + java.lang.Object ref = visibility_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + visibility_ = s; + } + return s; + } + } + /** + * required string visibility = 3; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes() { + java.lang.Object ref = visibility_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + visibility_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int MODALITY_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind modality_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 4; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField backingField_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + public boolean hasBackingField() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField getBackingField() { + return backingField_; + } + + public static final int GETTER_FIELD_NUMBER = 11; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getter_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + public boolean hasGetter() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getGetter() { + return getter_; + } + + public static final int SETTER_FIELD_NUMBER = 12; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction setter_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + public boolean hasSetter() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getSetter() { + return setter_; + } + + private void initFields() { + descriptor_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance(); + name_ = ""; + visibility_ = ""; + modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind.FINAL_MODALITY; + isVar_ = false; + isConst_ = false; + isLateinit_ = false; + isDelegated_ = false; + isExternal_ = false; + backingField_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance(); + getter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + setter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 (hasDescriptor()) { + if (!getDescriptor().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, descriptor_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getNameBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBytes(3, getVisibilityBytes()); + } + 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, descriptor_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBytesSize(2, getNameBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBytesSize(3, getVisibilityBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrPropertyOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + descriptor_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + visibility_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000200); + getter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000400); + setter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.descriptor_ = descriptor_; + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.getDefaultInstance()) return this; + if (other.hasDescriptor()) { + mergeDescriptor(other.getDescriptor()); + } + if (other.hasName()) { + bitField0_ |= 0x00000002; + name_ = other.name_; + + } + if (other.hasVisibility()) { + bitField0_ |= 0x00000004; + visibility_ = other.visibility_; + + } + 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 (hasDescriptor()) { + if (!getDescriptor().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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference descriptor_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public boolean hasDescriptor() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference getDescriptor() { + return descriptor_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder setDescriptor(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference value) { + if (value == null) { + throw new NullPointerException(); + } + descriptor_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder setDescriptor( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.Builder builderForValue) { + descriptor_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder mergeDescriptor(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + descriptor_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance()) { + descriptor_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.newBuilder(descriptor_).mergeFrom(value).buildPartial(); + } else { + descriptor_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.DescriptorReference descriptor = 1; + * + * 
+       * IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
+       *
+ */ + public Builder clearDescriptor() { + descriptor_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.DescriptorReference.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private java.lang.Object name_ = ""; + /** + * required string name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 2; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + + return this; + } + /** + * required string name = 2; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000002); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 2; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + + return this; + } + + private java.lang.Object visibility_ = ""; + /** + * required string visibility = 3; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string visibility = 3; + */ + public java.lang.String getVisibility() { + java.lang.Object ref = visibility_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + visibility_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string visibility = 3; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes() { + java.lang.Object ref = visibility_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + visibility_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string visibility = 3; + */ + public Builder setVisibility( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + visibility_ = value; + + return this; + } + /** + * required string visibility = 3; + */ + public Builder clearVisibility() { + bitField0_ = (bitField0_ & ~0x00000004); + visibility_ = getDefaultInstance().getVisibility(); + + return this; + } + /** + * required string visibility = 3; + */ + public Builder setVisibilityBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + visibility_ = value; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind.FINAL_MODALITY; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 4; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind getModality() { + return modality_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 4; + */ + public Builder setModality(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + modality_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 4; + */ + public Builder clearModality() { + bitField0_ = (bitField0_ & ~0x00000008); + modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField backingField_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + public boolean hasBackingField() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField getBackingField() { + return backingField_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + public Builder setBackingField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField value) { + if (value == null) { + throw new NullPointerException(); + } + backingField_ = value; + + bitField0_ |= 0x00000200; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + public Builder setBackingField( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.Builder builderForValue) { + backingField_ = builderForValue.build(); + + bitField0_ |= 0x00000200; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + public Builder mergeBackingField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField value) { + if (((bitField0_ & 0x00000200) == 0x00000200) && + backingField_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance()) { + backingField_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.newBuilder(backingField_).mergeFrom(value).buildPartial(); + } else { + backingField_ = value; + } + + bitField0_ |= 0x00000200; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField backing_field = 10; + */ + public Builder clearBackingField() { + backingField_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000200); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + public boolean hasGetter() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getGetter() { + return getter_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + public Builder setGetter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction value) { + if (value == null) { + throw new NullPointerException(); + } + getter_ = value; + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + public Builder setGetter( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.Builder builderForValue) { + getter_ = builderForValue.build(); + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + public Builder mergeGetter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction value) { + if (((bitField0_ & 0x00000400) == 0x00000400) && + getter_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance()) { + getter_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.newBuilder(getter_).mergeFrom(value).buildPartial(); + } else { + getter_ = value; + } + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction getter = 11; + */ + public Builder clearGetter() { + getter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000400); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction setter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + public boolean hasSetter() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getSetter() { + return setter_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + public Builder setSetter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction value) { + if (value == null) { + throw new NullPointerException(); + } + setter_ = value; + + bitField0_ |= 0x00000800; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + public Builder setSetter( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.Builder builderForValue) { + setter_ = builderForValue.build(); + + bitField0_ |= 0x00000800; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + public Builder mergeSetter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction value) { + if (((bitField0_ & 0x00000800) == 0x00000800) && + setter_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance()) { + setter_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.newBuilder(setter_).mergeFrom(value).buildPartial(); + } else { + setter_ = value; + } + + bitField0_ |= 0x00000800; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction setter = 12; + */ + public Builder clearSetter() { + setter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty) + } + + static { + defaultInstance = new IrProperty(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty) + } + + public interface IrVariableOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required string name = 1; + */ + boolean hasName(); + /** + * required string name = 1; + */ + java.lang.String getName(); + /** + * required string name = 1; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + boolean hasInitializer(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getInitializer(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable} + */ + public static final class IrVariable extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = bs; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000040) == 0x00000040)) { + subBuilder = initializer_.toBuilder(); + } + initializer_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 java.lang.Object name_; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int SYMBOL_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int TYPE_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression initializer_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getInitializer() { + return initializer_; + } + + private void initFields() { + name_ = ""; + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + isVar_ = false; + isConst_ = false; + isLateinit_ = false; + initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 (!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.writeBytes(1, getNameBytes()); + } + 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 + .computeBytesSize(1, getNameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariableOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + isVar_ = false; + bitField0_ = (bitField0_ & ~0x00000008); + isConst_ = false; + bitField0_ = (bitField0_ & ~0x00000010); + isLateinit_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + + } + 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 (!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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 1; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + /** + * required string name = 1; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 1; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 2; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + public Builder setType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + public Builder setType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + public Builder mergeType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + type_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 3; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getInitializer() { + return initializer_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + public Builder setInitializer(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + initializer_ = value; + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + public Builder setInitializer( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + initializer_ = builderForValue.build(); + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + public Builder mergeInitializer(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000040) == 0x00000040) && + initializer_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + initializer_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(initializer_).mergeFrom(value).buildPartial(); + } else { + initializer_ = value; + } + + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 7; + */ + public Builder clearInitializer() { + initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable) + } + + static { + defaultInstance = new IrVariable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable) + } + + public interface IrValueParameterOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required string name = 2; + */ + boolean hasName(); + /** + * required string name = 2; + */ + java.lang.String getName(); + /** + * required string name = 2; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + + /** + * required int32 index = 3; + */ + boolean hasIndex(); + /** + * required int32 index = 3; + */ + int getIndex(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + boolean hasType(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + boolean hasVarargElementType(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + boolean hasDefaultValue(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getDefaultValue(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter} + */ + public static final class IrValueParameter extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + name_ = bs; + break; + } + case 24: { + bitField0_ |= 0x00000004; + index_ = input.readInt32(); + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = type_.toBuilder(); + } + type_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(type_); + type_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 42: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = varargElementType_.toBuilder(); + } + varargElementType_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + subBuilder = defaultValue_.toBuilder(); + } + defaultValue_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int NAME_FIELD_NUMBER = 2; + private java.lang.Object name_; + /** + * required string name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType() { + return type_; + } + + public static final int VARARG_ELEMENT_TYPE_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex varargElementType_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + public boolean hasVarargElementType() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression defaultValue_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + public boolean hasDefaultValue() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getDefaultValue() { + return defaultValue_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + name_ = ""; + index_ = 0; + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + varargElementType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + isCrossinline_ = false; + isNoinline_ = false; + defaultValue_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 (!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.writeBytes(2, getNameBytes()); + } + 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 + .computeBytesSize(2, getNameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameterOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + index_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + varargElementType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); + isCrossinline_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + isNoinline_ = false; + bitField0_ = (bitField0_ & ~0x00000040); + defaultValue_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasName()) { + bitField0_ |= 0x00000002; + name_ = other.name_; + + } + 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 (!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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private java.lang.Object name_ = ""; + /** + * required string name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 2; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + + return this; + } + /** + * required string name = 2; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000002); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 2; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getType() { + return type_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + public Builder setType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + public Builder setType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + public Builder mergeType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + type_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + type_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex type = 4; + */ + public Builder clearType() { + type_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex varargElementType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + public boolean hasVarargElementType() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getVarargElementType() { + return varargElementType_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + public Builder setVarargElementType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + varargElementType_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + public Builder setVarargElementType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + varargElementType_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + public Builder mergeVarargElementType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + varargElementType_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.getDefaultInstance()) { + varargElementType_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.newBuilder(varargElementType_).mergeFrom(value).buildPartial(); + } else { + varargElementType_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex vararg_element_type = 5; + */ + public Builder clearVarargElementType() { + varargElementType_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression defaultValue_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + public boolean hasDefaultValue() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getDefaultValue() { + return defaultValue_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + public Builder setDefaultValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + defaultValue_ = value; + + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + public Builder setDefaultValue( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + defaultValue_ = builderForValue.build(); + + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + public Builder mergeDefaultValue(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000080) == 0x00000080) && + defaultValue_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + defaultValue_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(defaultValue_).mergeFrom(value).buildPartial(); + } else { + defaultValue_ = value; + } + + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression default_value = 8; + */ + public Builder clearDefaultValue() { + defaultValue_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter) + } + + static { + defaultInstance = new IrValueParameter(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter) + } + + public interface IrTypeParameterOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required string name = 2; + */ + boolean hasName(); + /** + * required string name = 2; + */ + java.lang.String getName(); + /** + * required string name = 2; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + + /** + * required int32 index = 3; + */ + boolean hasIndex(); + /** + * required int32 index = 3; + */ + int getIndex(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 4; + */ + boolean hasVariance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance getVariance(); + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + java.util.List + getSuperTypeList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getSuperType(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrTypeParameter} + */ + public static final class IrTypeParameter extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + name_ = bs; + break; + } + case 24: { + bitField0_ |= 0x00000004; + index_ = input.readInt32(); + break; + } + case 32: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int NAME_FIELD_NUMBER = 2; + private java.lang.Object name_; + /** + * required string name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance variance_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 4; + */ + public boolean hasVariance() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance getVariance() { + return variance_; + } + + public static final int SUPER_TYPE_FIELD_NUMBER = 5; + private java.util.List superType_; + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public java.util.List getSuperTypeList() { + return superType_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public java.util.List + getSuperTypeOrBuilderList() { + return superType_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public int getSuperTypeCount() { + return superType_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getSuperType(int index) { + return superType_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + name_ = ""; + index_ = 0; + variance_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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; + } + 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.writeBytes(2, getNameBytes()); + } + 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 + .computeBytesSize(2, getNameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + index_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + variance_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasName()) { + bitField0_ |= 0x00000002; + name_ = other.name_; + + } + 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; + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private java.lang.Object name_ = ""; + /** + * required string name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 2; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + + return this; + } + /** + * required string name = 2; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000002); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 2; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance variance_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance.IN; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 4; + */ + public boolean hasVariance() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance getVariance() { + return variance_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 4; + */ + public Builder setVariance(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeVariance value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + variance_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeVariance variance = 4; + */ + public Builder clearVariance() { + bitField0_ = (bitField0_ & ~0x00000008); + variance_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public java.util.List getSuperTypeList() { + return java.util.Collections.unmodifiableList(superType_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public int getSuperTypeCount() { + return superType_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getSuperType(int index) { + return superType_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public Builder setSuperType( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public Builder setSuperType( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public Builder addSuperType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public Builder addSuperType( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public Builder addSuperType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public Builder addSuperType( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 5; + */ + public Builder clearSuperType() { + superType_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrTypeParameter) + } + + static { + defaultInstance = new IrTypeParameter(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter) + } + + public interface IrTypeParameterContainerOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + java.util.List + getTypeParameterList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getTypeParameter(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + int getTypeParameterCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer} + */ + public static final class IrTypeParameterContainer extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + typeParameter_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + typeParameter_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public java.util.List getTypeParameterList() { + return typeParameter_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public java.util.List + getTypeParameterOrBuilderList() { + return typeParameter_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public int getTypeParameterCount() { + return typeParameter_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getTypeParameter(int index) { + return typeParameter_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainerOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public java.util.List getTypeParameterList() { + return java.util.Collections.unmodifiableList(typeParameter_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public int getTypeParameterCount() { + return typeParameter_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getTypeParameter(int index) { + return typeParameter_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public Builder setTypeParameter( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeParameterIsMutable(); + typeParameter_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public Builder setTypeParameter( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + ensureTypeParameterIsMutable(); + typeParameter_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public Builder addTypeParameter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeParameterIsMutable(); + typeParameter_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public Builder addTypeParameter( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + ensureTypeParameterIsMutable(); + typeParameter_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public Builder addTypeParameter( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + ensureTypeParameterIsMutable(); + typeParameter_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public Builder addTypeParameter( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + ensureTypeParameterIsMutable(); + typeParameter_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public Builder clearTypeParameter() { + typeParameter_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration type_parameter = 1; + */ + public Builder removeTypeParameter(int index) { + ensureTypeParameterIsMutable(); + typeParameter_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer) + } + + static { + defaultInstance = new IrTypeParameterContainer(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer) + } + + public interface IrClassOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required string name = 2; + */ + boolean hasName(); + /** + * required string name = 2; + */ + java.lang.String getName(); + /** + * required string name = 2; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ClassKind kind = 3; + */ + boolean hasKind(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ClassKind kind = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind getKind(); + + /** + * required string visibility = 4; + */ + boolean hasVisibility(); + /** + * required string visibility = 4; + */ + java.lang.String getVisibility(); + /** + * required string visibility = 4; + */ + org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 5; + */ + boolean hasModality(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 5; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + boolean hasThisReceiver(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getThisReceiver(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + boolean hasTypeParameters(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer getTypeParameters(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + boolean hasDeclarationContainer(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer getDeclarationContainer(); + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + java.util.List + getSuperTypeList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getSuperType(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + int getSuperTypeCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass} + */ + public static final class IrClass extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + name_ = bs; + break; + } + case 24: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind.valueOf(rawValue); + if (value == null) { + unknownFieldsCodedOutput.writeRawVarint32(tag); + unknownFieldsCodedOutput.writeRawVarint32(rawValue); + } else { + bitField0_ |= 0x00000004; + kind_ = value; + } + break; + } + case 34: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000008; + visibility_ = bs; + break; + } + case 40: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000400) == 0x00000400)) { + subBuilder = thisReceiver_.toBuilder(); + } + thisReceiver_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(thisReceiver_); + thisReceiver_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000400; + break; + } + case 98: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.Builder subBuilder = null; + if (((bitField0_ & 0x00000800) == 0x00000800)) { + subBuilder = typeParameters_.toBuilder(); + } + typeParameters_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(typeParameters_); + typeParameters_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000800; + break; + } + case 106: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer.Builder subBuilder = null; + if (((bitField0_ & 0x00001000) == 0x00001000)) { + subBuilder = declarationContainer_.toBuilder(); + } + declarationContainer_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int NAME_FIELD_NUMBER = 2; + private java.lang.Object name_; + /** + * required string name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int KIND_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind kind_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ClassKind kind = 3; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ClassKind kind = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind getKind() { + return kind_; + } + + public static final int VISIBILITY_FIELD_NUMBER = 4; + private java.lang.Object visibility_; + /** + * required string visibility = 4; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required string visibility = 4; + */ + public java.lang.String getVisibility() { + java.lang.Object ref = visibility_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + visibility_ = s; + } + return s; + } + } + /** + * required string visibility = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes() { + java.lang.Object ref = visibility_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + visibility_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + public static final int MODALITY_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind modality_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 5; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration thisReceiver_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + public boolean hasThisReceiver() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getThisReceiver() { + return thisReceiver_; + } + + public static final int TYPE_PARAMETERS_FIELD_NUMBER = 12; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer typeParameters_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + public boolean hasTypeParameters() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer getTypeParameters() { + return typeParameters_; + } + + public static final int DECLARATION_CONTAINER_FIELD_NUMBER = 13; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer declarationContainer_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + public boolean hasDeclarationContainer() { + return ((bitField0_ & 0x00001000) == 0x00001000); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer getDeclarationContainer() { + return declarationContainer_; + } + + public static final int SUPER_TYPE_FIELD_NUMBER = 14; + private java.util.List superType_; + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public java.util.List getSuperTypeList() { + return superType_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public java.util.List + getSuperTypeOrBuilderList() { + return superType_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public int getSuperTypeCount() { + return superType_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getSuperType(int index) { + return superType_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndexOrBuilder getSuperTypeOrBuilder( + int index) { + return superType_.get(index); + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + name_ = ""; + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind.CLASS; + visibility_ = ""; + modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind.FINAL_MODALITY; + isCompanion_ = false; + isInner_ = false; + isData_ = false; + isExternal_ = false; + isInline_ = false; + thisReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + typeParameters_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance(); + declarationContainer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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 (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.writeBytes(2, getNameBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeEnum(3, kind_.getNumber()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeBytes(4, getVisibilityBytes()); + } + 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 + .computeBytesSize(2, getNameBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeEnumSize(3, kind_.getNumber()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBytesSize(4, getVisibilityBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClassOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind.CLASS; + bitField0_ = (bitField0_ & ~0x00000004); + visibility_ = ""; + bitField0_ = (bitField0_ & ~0x00000008); + modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000400); + typeParameters_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000800); + declarationContainer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.getDefaultInstance()) return this; + if (other.hasSymbol()) { + mergeSymbol(other.getSymbol()); + } + if (other.hasName()) { + bitField0_ |= 0x00000002; + name_ = other.name_; + + } + if (other.hasKind()) { + setKind(other.getKind()); + } + if (other.hasVisibility()) { + bitField0_ |= 0x00000008; + visibility_ = other.visibility_; + + } + 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 (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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private java.lang.Object name_ = ""; + /** + * required string name = 2; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string name = 2; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 2; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 2; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + + return this; + } + /** + * required string name = 2; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000002); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 2; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind.CLASS; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ClassKind kind = 3; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ClassKind kind = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind getKind() { + return kind_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ClassKind kind = 3; + */ + public Builder setKind(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + kind_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ClassKind kind = 3; + */ + public Builder clearKind() { + bitField0_ = (bitField0_ & ~0x00000004); + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ClassKind.CLASS; + + return this; + } + + private java.lang.Object visibility_ = ""; + /** + * required string visibility = 4; + */ + public boolean hasVisibility() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required string visibility = 4; + */ + public java.lang.String getVisibility() { + java.lang.Object ref = visibility_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + visibility_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string visibility = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getVisibilityBytes() { + java.lang.Object ref = visibility_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + visibility_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string visibility = 4; + */ + public Builder setVisibility( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + visibility_ = value; + + return this; + } + /** + * required string visibility = 4; + */ + public Builder clearVisibility() { + bitField0_ = (bitField0_ & ~0x00000008); + visibility_ = getDefaultInstance().getVisibility(); + + return this; + } + /** + * required string visibility = 4; + */ + public Builder setVisibilityBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + visibility_ = value; + + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind.FINAL_MODALITY; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 5; + */ + public boolean hasModality() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind getModality() { + return modality_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 5; + */ + public Builder setModality(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.ModalityKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + modality_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.ModalityKind modality = 5; + */ + public Builder clearModality() { + bitField0_ = (bitField0_ & ~0x00000010); + modality_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration thisReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + public boolean hasThisReceiver() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getThisReceiver() { + return thisReceiver_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + public Builder setThisReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + thisReceiver_ = value; + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + public Builder setThisReceiver( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + thisReceiver_ = builderForValue.build(); + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + public Builder mergeThisReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (((bitField0_ & 0x00000400) == 0x00000400) && + thisReceiver_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance()) { + thisReceiver_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.newBuilder(thisReceiver_).mergeFrom(value).buildPartial(); + } else { + thisReceiver_ = value; + } + + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration this_receiver = 11; + */ + public Builder clearThisReceiver() { + thisReceiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000400); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer typeParameters_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + public boolean hasTypeParameters() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer getTypeParameters() { + return typeParameters_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + public Builder setTypeParameters(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer value) { + if (value == null) { + throw new NullPointerException(); + } + typeParameters_ = value; + + bitField0_ |= 0x00000800; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + public Builder setTypeParameters( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.Builder builderForValue) { + typeParameters_ = builderForValue.build(); + + bitField0_ |= 0x00000800; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + public Builder mergeTypeParameters(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer value) { + if (((bitField0_ & 0x00000800) == 0x00000800) && + typeParameters_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance()) { + typeParameters_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.newBuilder(typeParameters_).mergeFrom(value).buildPartial(); + } else { + typeParameters_ = value; + } + + bitField0_ |= 0x00000800; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameterContainer type_parameters = 12; + */ + public Builder clearTypeParameters() { + typeParameters_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameterContainer.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer declarationContainer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + public boolean hasDeclarationContainer() { + return ((bitField0_ & 0x00001000) == 0x00001000); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer getDeclarationContainer() { + return declarationContainer_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + public Builder setDeclarationContainer(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer value) { + if (value == null) { + throw new NullPointerException(); + } + declarationContainer_ = value; + + bitField0_ |= 0x00001000; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + public Builder setDeclarationContainer( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer.Builder builderForValue) { + declarationContainer_ = builderForValue.build(); + + bitField0_ |= 0x00001000; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + public Builder mergeDeclarationContainer(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer value) { + if (((bitField0_ & 0x00001000) == 0x00001000) && + declarationContainer_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer.getDefaultInstance()) { + declarationContainer_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationContainer.newBuilder(declarationContainer_).mergeFrom(value).buildPartial(); + } else { + declarationContainer_ = value; + } + + bitField0_ |= 0x00001000; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationContainer declaration_container = 13; + */ + public Builder clearDeclarationContainer() { + declarationContainer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public java.util.List getSuperTypeList() { + return java.util.Collections.unmodifiableList(superType_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public int getSuperTypeCount() { + return superType_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex getSuperType(int index) { + return superType_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public Builder setSuperType( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public Builder setSuperType( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public Builder addSuperType(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public Builder addSuperType( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex value) { + if (value == null) { + throw new NullPointerException(); + } + ensureSuperTypeIsMutable(); + superType_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public Builder addSuperType( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public Builder addSuperType( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeIndex.Builder builderForValue) { + ensureSuperTypeIsMutable(); + superType_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public Builder clearSuperType() { + superType_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00002000); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeIndex super_type = 14; + */ + public Builder removeSuperType(int index) { + ensureSuperTypeIsMutable(); + superType_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass) + } + + static { + defaultInstance = new IrClass(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass) + } + + public interface IrEnumEntryOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + boolean hasInitializer(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getInitializer(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + boolean hasCorrespondingClass(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getCorrespondingClass(); + + /** + * required string name = 4; + */ + boolean hasName(); + /** + * required string name = 4; + */ + java.lang.String getName(); + /** + * required string name = 4; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry} + */ + public static final class IrEnumEntry extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = initializer_.toBuilder(); + } + initializer_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(initializer_); + initializer_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = correspondingClass_.toBuilder(); + } + correspondingClass_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(correspondingClass_); + correspondingClass_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000008; + name_ = 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 { + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int INITIALIZER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression initializer_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getInitializer() { + return initializer_; + } + + public static final int CORRESPONDING_CLASS_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration correspondingClass_; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + public boolean hasCorrespondingClass() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getCorrespondingClass() { + return correspondingClass_; + } + + public static final int NAME_FIELD_NUMBER = 4; + private java.lang.Object name_; + /** + * required string name = 4; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required string name = 4; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + correspondingClass_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + name_ = ""; + } + 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; + } + } + 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.writeBytes(4, getNameBytes()); + } + 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 + .computeBytesSize(4, getNameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntryOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + correspondingClass_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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()) { + bitField0_ |= 0x00000008; + name_ = other.name_; + + } + 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; + } + } + return true; + } + + public Builder mergeFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public boolean hasInitializer() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getInitializer() { + return initializer_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public Builder setInitializer(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + initializer_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public Builder setInitializer( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + initializer_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public Builder mergeInitializer(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + initializer_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + initializer_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(initializer_).mergeFrom(value).buildPartial(); + } else { + initializer_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression initializer = 2; + */ + public Builder clearInitializer() { + initializer_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration correspondingClass_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + public boolean hasCorrespondingClass() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getCorrespondingClass() { + return correspondingClass_; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + public Builder setCorrespondingClass(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + correspondingClass_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + public Builder setCorrespondingClass( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + correspondingClass_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + public Builder mergeCorrespondingClass(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + correspondingClass_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance()) { + correspondingClass_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.newBuilder(correspondingClass_).mergeFrom(value).buildPartial(); + } else { + correspondingClass_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration corresponding_class = 3; + */ + public Builder clearCorrespondingClass() { + correspondingClass_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private java.lang.Object name_ = ""; + /** + * required string name = 4; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required string name = 4; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 4; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 4; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + name_ = value; + + return this; + } + /** + * required string name = 4; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000008); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 4; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + name_ = value; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry) + } + + static { + defaultInstance = new IrEnumEntry(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry) + } + + public interface IrAnonymousInitOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + boolean hasSymbol(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + boolean hasBody(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getBody(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit} + */ + public static final class IrAnonymousInit extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = symbol_.toBuilder(); + } + symbol_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(symbol_); + symbol_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = body_.toBuilder(); + } + body_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + + public static final int BODY_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement body_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getBody() { + return body_; + } + + private void initFields() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInitOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public boolean hasSymbol() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol getSymbol() { + return symbol_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (value == null) { + throw new NullPointerException(); + } + symbol_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder setSymbol( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.Builder builderForValue) { + symbol_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder mergeSymbol(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + symbol_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance()) { + symbol_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.newBuilder(symbol_).mergeFrom(value).buildPartial(); + } else { + symbol_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSymbol symbol = 1; + */ + public Builder clearSymbol() { + symbol_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSymbol.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + public boolean hasBody() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getBody() { + return body_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + public Builder setBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + body_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + public Builder setBody( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + body_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + public Builder mergeBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + body_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance()) { + body_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.newBuilder(body_).mergeFrom(value).buildPartial(); + } else { + body_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement body = 2; + */ + public Builder clearBody() { + body_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit) + } + + static { + defaultInstance = new IrAnonymousInit(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit) + } + + public interface IrDeclaratorOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + boolean hasIrAnonymousInit(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit getIrAnonymousInit(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + boolean hasIrClass(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass getIrClass(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + boolean hasIrConstructor(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor getIrConstructor(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + boolean hasIrEnumEntry(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry getIrEnumEntry(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + boolean hasIrField(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField getIrField(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + boolean hasIrFunction(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getIrFunction(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + boolean hasIrProperty(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty getIrProperty(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + boolean hasIrTypeAlias(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias getIrTypeAlias(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + boolean hasIrTypeParameter(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter getIrTypeParameter(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + boolean hasIrVariable(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable getIrVariable(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter ir_value_parameter = 11; + */ + boolean hasIrValueParameter(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter ir_value_parameter = 11; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter getIrValueParameter(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit.Builder subBuilder = null; + if (declaratorCase_ == 1) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 1; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.Builder subBuilder = null; + if (declaratorCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 2; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor.Builder subBuilder = null; + if (declaratorCase_ == 3) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 3; + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry.Builder subBuilder = null; + if (declaratorCase_ == 4) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 4; + break; + } + case 42: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.Builder subBuilder = null; + if (declaratorCase_ == 5) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 5; + break; + } + case 50: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.Builder subBuilder = null; + if (declaratorCase_ == 6) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 6; + break; + } + case 58: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.Builder subBuilder = null; + if (declaratorCase_ == 7) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 7; + break; + } + case 66: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias.Builder subBuilder = null; + if (declaratorCase_ == 8) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 8; + break; + } + case 74: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.Builder subBuilder = null; + if (declaratorCase_ == 9) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 9; + break; + } + case 82: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.Builder subBuilder = null; + if (declaratorCase_ == 10) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable) declarator_); + declarator_ = subBuilder.buildPartial(); + } + declaratorCase_ = 10; + break; + } + case 90: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter.Builder subBuilder = null; + if (declaratorCase_ == 11) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter) declarator_).toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + public boolean hasIrAnonymousInit() { + return declaratorCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit getIrAnonymousInit() { + if (declaratorCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit.getDefaultInstance(); + } + + public static final int IR_CLASS_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + public boolean hasIrClass() { + return declaratorCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass getIrClass() { + if (declaratorCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.getDefaultInstance(); + } + + public static final int IR_CONSTRUCTOR_FIELD_NUMBER = 3; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + public boolean hasIrConstructor() { + return declaratorCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor getIrConstructor() { + if (declaratorCase_ == 3) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor.getDefaultInstance(); + } + + public static final int IR_ENUM_ENTRY_FIELD_NUMBER = 4; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + public boolean hasIrEnumEntry() { + return declaratorCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry getIrEnumEntry() { + if (declaratorCase_ == 4) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry.getDefaultInstance(); + } + + public static final int IR_FIELD_FIELD_NUMBER = 5; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + public boolean hasIrField() { + return declaratorCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField getIrField() { + if (declaratorCase_ == 5) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance(); + } + + public static final int IR_FUNCTION_FIELD_NUMBER = 6; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + public boolean hasIrFunction() { + return declaratorCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getIrFunction() { + if (declaratorCase_ == 6) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + } + + public static final int IR_PROPERTY_FIELD_NUMBER = 7; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + public boolean hasIrProperty() { + return declaratorCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty getIrProperty() { + if (declaratorCase_ == 7) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.getDefaultInstance(); + } + + public static final int IR_TYPE_ALIAS_FIELD_NUMBER = 8; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + public boolean hasIrTypeAlias() { + return declaratorCase_ == 8; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias getIrTypeAlias() { + if (declaratorCase_ == 8) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias.getDefaultInstance(); + } + + public static final int IR_TYPE_PARAMETER_FIELD_NUMBER = 9; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + public boolean hasIrTypeParameter() { + return declaratorCase_ == 9; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter getIrTypeParameter() { + if (declaratorCase_ == 9) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.getDefaultInstance(); + } + + public static final int IR_VARIABLE_FIELD_NUMBER = 10; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + public boolean hasIrVariable() { + return declaratorCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable getIrVariable() { + if (declaratorCase_ == 10) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.getDefaultInstance(); + } + + public static final int IR_VALUE_PARAMETER_FIELD_NUMBER = 11; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter ir_value_parameter = 11; + */ + public boolean hasIrValueParameter() { + return declaratorCase_ == 11; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter ir_value_parameter = 11; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter getIrValueParameter() { + if (declaratorCase_ == 11) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit) declarator_); + } + if (declaratorCase_ == 2) { + output.writeMessage(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass) declarator_); + } + if (declaratorCase_ == 3) { + output.writeMessage(3, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor) declarator_); + } + if (declaratorCase_ == 4) { + output.writeMessage(4, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry) declarator_); + } + if (declaratorCase_ == 5) { + output.writeMessage(5, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField) declarator_); + } + if (declaratorCase_ == 6) { + output.writeMessage(6, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction) declarator_); + } + if (declaratorCase_ == 7) { + output.writeMessage(7, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty) declarator_); + } + if (declaratorCase_ == 8) { + output.writeMessage(8, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias) declarator_); + } + if (declaratorCase_ == 9) { + output.writeMessage(9, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter) declarator_); + } + if (declaratorCase_ == 10) { + output.writeMessage(10, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable) declarator_); + } + if (declaratorCase_ == 11) { + output.writeMessage(11, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit) declarator_); + } + if (declaratorCase_ == 2) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass) declarator_); + } + if (declaratorCase_ == 3) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor) declarator_); + } + if (declaratorCase_ == 4) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry) declarator_); + } + if (declaratorCase_ == 5) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField) declarator_); + } + if (declaratorCase_ == 6) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(6, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction) declarator_); + } + if (declaratorCase_ == 7) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(7, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty) declarator_); + } + if (declaratorCase_ == 8) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(8, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias) declarator_); + } + if (declaratorCase_ == 9) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(9, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter) declarator_); + } + if (declaratorCase_ == 10) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(10, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable) declarator_); + } + if (declaratorCase_ == 11) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(11, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaratorOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + public boolean hasIrAnonymousInit() { + return declaratorCase_ == 1; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit getIrAnonymousInit() { + if (declaratorCase_ == 1) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + public Builder setIrAnonymousInit(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + public Builder setIrAnonymousInit( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + public Builder mergeIrAnonymousInit(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit value) { + if (declaratorCase_ == 1 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrAnonymousInit) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 1; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrAnonymousInit ir_anonymous_init = 1; + */ + public Builder clearIrAnonymousInit() { + if (declaratorCase_ == 1) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + public boolean hasIrClass() { + return declaratorCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass getIrClass() { + if (declaratorCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + public Builder setIrClass(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + public Builder setIrClass( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + public Builder mergeIrClass(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass value) { + if (declaratorCase_ == 2 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrClass) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrClass ir_class = 2; + */ + public Builder clearIrClass() { + if (declaratorCase_ == 2) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + public boolean hasIrConstructor() { + return declaratorCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor getIrConstructor() { + if (declaratorCase_ == 3) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + public Builder setIrConstructor(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + public Builder setIrConstructor( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + public Builder mergeIrConstructor(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor value) { + if (declaratorCase_ == 3 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrConstructor) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrConstructor ir_constructor = 3; + */ + public Builder clearIrConstructor() { + if (declaratorCase_ == 3) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + public boolean hasIrEnumEntry() { + return declaratorCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry getIrEnumEntry() { + if (declaratorCase_ == 4) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + public Builder setIrEnumEntry(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + public Builder setIrEnumEntry( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + public Builder mergeIrEnumEntry(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry value) { + if (declaratorCase_ == 4 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrEnumEntry) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrEnumEntry ir_enum_entry = 4; + */ + public Builder clearIrEnumEntry() { + if (declaratorCase_ == 4) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + public boolean hasIrField() { + return declaratorCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField getIrField() { + if (declaratorCase_ == 5) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + public Builder setIrField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + public Builder setIrField( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + public Builder mergeIrField(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField value) { + if (declaratorCase_ == 5 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrField) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrField ir_field = 5; + */ + public Builder clearIrField() { + if (declaratorCase_ == 5) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + public boolean hasIrFunction() { + return declaratorCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction getIrFunction() { + if (declaratorCase_ == 6) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + public Builder setIrFunction(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + public Builder setIrFunction( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + public Builder mergeIrFunction(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction value) { + if (declaratorCase_ == 6 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrFunction) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrFunction ir_function = 6; + */ + public Builder clearIrFunction() { + if (declaratorCase_ == 6) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + public boolean hasIrProperty() { + return declaratorCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty getIrProperty() { + if (declaratorCase_ == 7) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + public Builder setIrProperty(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + public Builder setIrProperty( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + public Builder mergeIrProperty(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty value) { + if (declaratorCase_ == 7 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrProperty) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrProperty ir_property = 7; + */ + public Builder clearIrProperty() { + if (declaratorCase_ == 7) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + public boolean hasIrTypeAlias() { + return declaratorCase_ == 8; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias getIrTypeAlias() { + if (declaratorCase_ == 8) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + public Builder setIrTypeAlias(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + public Builder setIrTypeAlias( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + public Builder mergeIrTypeAlias(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias value) { + if (declaratorCase_ == 8 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeAlias) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 8; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeAlias ir_type_alias = 8; + */ + public Builder clearIrTypeAlias() { + if (declaratorCase_ == 8) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + public boolean hasIrTypeParameter() { + return declaratorCase_ == 9; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter getIrTypeParameter() { + if (declaratorCase_ == 9) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + public Builder setIrTypeParameter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + public Builder setIrTypeParameter( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + public Builder mergeIrTypeParameter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter value) { + if (declaratorCase_ == 9 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrTypeParameter) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 9; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrTypeParameter ir_type_parameter = 9; + */ + public Builder clearIrTypeParameter() { + if (declaratorCase_ == 9) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + public boolean hasIrVariable() { + return declaratorCase_ == 10; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable getIrVariable() { + if (declaratorCase_ == 10) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + public Builder setIrVariable(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + public Builder setIrVariable( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + public Builder mergeIrVariable(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable value) { + if (declaratorCase_ == 10 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrVariable) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 10; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrVariable ir_variable = 10; + */ + public Builder clearIrVariable() { + if (declaratorCase_ == 10) { + declaratorCase_ = 0; + declarator_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter ir_value_parameter = 11; + */ + public boolean hasIrValueParameter() { + return declaratorCase_ == 11; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter ir_value_parameter = 11; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter getIrValueParameter() { + if (declaratorCase_ == 11) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter) declarator_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter ir_value_parameter = 11; + */ + public Builder setIrValueParameter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + declaratorCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter ir_value_parameter = 11; + */ + public Builder setIrValueParameter( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter.Builder builderForValue) { + declarator_ = builderForValue.build(); + + declaratorCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrValueParameter ir_value_parameter = 11; + */ + public Builder mergeIrValueParameter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter value) { + if (declaratorCase_ == 11 && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter.getDefaultInstance()) { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrValueParameter) declarator_) + .mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + declaratorCase_ = 11; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrDeclarator) + } + + static { + defaultInstance = new IrDeclarator(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator) + } + + public interface IrDeclarationOriginOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required string name = 1; + */ + boolean hasName(); + /** + * required string name = 1; + */ + java.lang.String getName(); + /** + * required string name = 1; + */ + org.jetbrains.kotlin.protobuf.ByteString + getNameBytes(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin} + */ + public static final class IrDeclarationOrigin extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = 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 { + 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_; + public static final int NAME_FIELD_NUMBER = 1; + private java.lang.Object name_; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + private void initFields() { + name_ = ""; + } + 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; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getNameBytes()); + } + 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 + .computeBytesSize(1, getNameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOriginOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin(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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * required string name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 1; + */ + public org.jetbrains.kotlin.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string name = 1; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + /** + * required string name = 1; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + + return this; + } + /** + * required string name = 1; + */ + public Builder setNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin) + } + + static { + defaultInstance = new IrDeclarationOrigin(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin) + } + + public interface IrDeclarationOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin getOrigin(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + boolean hasCoordinates(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + boolean hasAnnotations(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + boolean hasDeclarator(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator getDeclarator(); + + /** + * required string file_name = 5; + * + * 
+     *repeated IrDeclaration nested = 5;
+     *
+ */ + boolean hasFileName(); + /** + * required string file_name = 5; + * + * 
+     *repeated IrDeclaration nested = 5;
+     *
+ */ + java.lang.String getFileName(); + /** + * required string file_name = 5; + * + * 
+     *repeated IrDeclaration nested = 5;
+     *
+ */ + org.jetbrains.kotlin.protobuf.ByteString + getFileNameBytes(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration} + */ + public static final class IrDeclaration extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = coordinates_.toBuilder(); + } + coordinates_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(coordinates_); + coordinates_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = annotations_.toBuilder(); + } + annotations_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(annotations_); + annotations_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = declarator_.toBuilder(); + } + declarator_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(declarator_); + declarator_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 42: { + org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000010; + fileName_ = 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 { + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin origin_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin getOrigin() { + return origin_; + } + + public static final int COORDINATES_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates coordinates_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates() { + return coordinates_; + } + + public static final int ANNOTATIONS_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations annotations_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations() { + return annotations_; + } + + public static final int DECLARATOR_FIELD_NUMBER = 4; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator declarator_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + public boolean hasDeclarator() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator getDeclarator() { + return declarator_; + } + + public static final int FILE_NAME_FIELD_NUMBER = 5; + private java.lang.Object fileName_; + /** + * required string file_name = 5; + * + * 
+     *repeated IrDeclaration nested = 5;
+     *
+ */ + public boolean hasFileName() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required string file_name = 5; + * + * 
+     *repeated IrDeclaration nested = 5;
+     *
+ */ + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + fileName_ = s; + } + return s; + } + } + /** + * required string file_name = 5; + * + * 
+     *repeated IrDeclaration nested = 5;
+     *
+ */ + public org.jetbrains.kotlin.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + + private void initFields() { + origin_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.getDefaultInstance(); + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.getDefaultInstance(); + fileName_ = ""; + } + 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 (!hasFileName()) { + 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_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBytes(5, getFileNameBytes()); + } + 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_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeBytesSize(5, getFileNameBytes()); + } + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + origin_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + fileName_ = ""; + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.fileName_ = fileName_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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()); + } + if (other.hasFileName()) { + bitField0_ |= 0x00000010; + fileName_ = other.fileName_; + + } + 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 (!hasFileName()) { + + 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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin origin_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + public Builder setOrigin(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + public Builder setOrigin( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + origin_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarationOrigin origin = 1; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarationOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates() { + return coordinates_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public Builder setCoordinates(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates value) { + if (value == null) { + throw new NullPointerException(); + } + coordinates_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public Builder setCoordinates( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.Builder builderForValue) { + coordinates_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public Builder mergeCoordinates(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + coordinates_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance()) { + coordinates_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.newBuilder(coordinates_).mergeFrom(value).buildPartial(); + } else { + coordinates_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 2; + */ + public Builder clearCoordinates() { + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + public boolean hasAnnotations() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations getAnnotations() { + return annotations_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + public Builder setAnnotations(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations value) { + if (value == null) { + throw new NullPointerException(); + } + annotations_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + public Builder setAnnotations( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.Builder builderForValue) { + annotations_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + public Builder mergeAnnotations(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + annotations_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance()) { + annotations_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.newBuilder(annotations_).mergeFrom(value).buildPartial(); + } else { + annotations_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Annotations annotations = 3; + */ + public Builder clearAnnotations() { + annotations_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Annotations.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + public boolean hasDeclarator() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator getDeclarator() { + return declarator_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + public Builder setDeclarator(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator value) { + if (value == null) { + throw new NullPointerException(); + } + declarator_ = value; + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + public Builder setDeclarator( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.Builder builderForValue) { + declarator_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + public Builder mergeDeclarator(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + declarator_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.getDefaultInstance()) { + declarator_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.newBuilder(declarator_).mergeFrom(value).buildPartial(); + } else { + declarator_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclarator declarator = 4; + */ + public Builder clearDeclarator() { + declarator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclarator.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + private java.lang.Object fileName_ = ""; + /** + * required string file_name = 5; + * + * 
+       *repeated IrDeclaration nested = 5;
+       *
+ */ + public boolean hasFileName() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required string file_name = 5; + * + * 
+       *repeated IrDeclaration nested = 5;
+       *
+ */ + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (!(ref instanceof java.lang.String)) { + org.jetbrains.kotlin.protobuf.ByteString bs = + (org.jetbrains.kotlin.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + fileName_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string file_name = 5; + * + * 
+       *repeated IrDeclaration nested = 5;
+       *
+ */ + public org.jetbrains.kotlin.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof String) { + org.jetbrains.kotlin.protobuf.ByteString b = + org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (org.jetbrains.kotlin.protobuf.ByteString) ref; + } + } + /** + * required string file_name = 5; + * + * 
+       *repeated IrDeclaration nested = 5;
+       *
+ */ + public Builder setFileName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + fileName_ = value; + + return this; + } + /** + * required string file_name = 5; + * + * 
+       *repeated IrDeclaration nested = 5;
+       *
+ */ + public Builder clearFileName() { + bitField0_ = (bitField0_ & ~0x00000010); + fileName_ = getDefaultInstance().getFileName(); + + return this; + } + /** + * required string file_name = 5; + * + * 
+       *repeated IrDeclaration nested = 5;
+       *
+ */ + public Builder setFileNameBytes( + org.jetbrains.kotlin.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + fileName_ = value; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration) + } + + static { + defaultInstance = new IrDeclaration(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration) + } + + public interface IrBranchOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + boolean hasCondition(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getCondition(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + boolean hasResult(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getResult(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch} + */ + public static final class IrBranch extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = condition_.toBuilder(); + } + condition_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(condition_); + condition_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = result_.toBuilder(); + } + result_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression condition_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + public boolean hasCondition() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getCondition() { + return condition_; + } + + public static final int RESULT_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression result_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getResult() { + return result_; + } + + private void initFields() { + condition_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranchOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + condition_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression condition_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + public boolean hasCondition() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getCondition() { + return condition_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + public Builder setCondition(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + condition_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + public Builder setCondition( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + condition_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + public Builder mergeCondition(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + condition_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + condition_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(condition_).mergeFrom(value).buildPartial(); + } else { + condition_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression condition = 1; + */ + public Builder clearCondition() { + condition_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getResult() { + return result_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public Builder setResult(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + result_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public Builder setResult( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + result_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public Builder mergeResult(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + result_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + result_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(result_).mergeFrom(value).buildPartial(); + } else { + result_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public Builder clearResult() { + result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch) + } + + static { + defaultInstance = new IrBranch(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch) + } + + public interface IrBlockBodyOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + java.util.List + getStatementList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getStatement(int index); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + int getStatementCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody} + */ + public static final class IrBlockBody extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + statement_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + statement_.add(input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public java.util.List getStatementList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public java.util.List + getStatementOrBuilderList() { + return statement_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBodyOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public java.util.List getStatementList() { + return java.util.Collections.unmodifiableList(statement_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public int getStatementCount() { + return statement_.size(); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getStatement(int index) { + return statement_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.set(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder setStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder addStatement(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement value) { + if (value == null) { + throw new NullPointerException(); + } + ensureStatementIsMutable(); + statement_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder addStatement( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder addStatement( + int index, org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.Builder builderForValue) { + ensureStatementIsMutable(); + statement_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder clearStatement() { + statement_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement statement = 1; + */ + public Builder removeStatement(int index) { + ensureStatementIsMutable(); + statement_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody) + } + + static { + defaultInstance = new IrBlockBody(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody) + } + + public interface IrCatchOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + boolean hasCatchParameter(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getCatchParameter(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + boolean hasResult(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getResult(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch} + */ + public static final class IrCatch extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = catchParameter_.toBuilder(); + } + catchParameter_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(catchParameter_); + catchParameter_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = result_.toBuilder(); + } + result_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration catchParameter_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + public boolean hasCatchParameter() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getCatchParameter() { + return catchParameter_; + } + + public static final int RESULT_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression result_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getResult() { + return result_; + } + + private void initFields() { + catchParameter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatchOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + catchParameter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration catchParameter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + public boolean hasCatchParameter() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getCatchParameter() { + return catchParameter_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + public Builder setCatchParameter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + catchParameter_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + public Builder setCatchParameter( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + catchParameter_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + public Builder mergeCatchParameter(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + catchParameter_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance()) { + catchParameter_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.newBuilder(catchParameter_).mergeFrom(value).buildPartial(); + } else { + catchParameter_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration catch_parameter = 1; + */ + public Builder clearCatchParameter() { + catchParameter_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public boolean hasResult() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getResult() { + return result_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public Builder setResult(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + result_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public Builder setResult( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + result_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public Builder mergeResult(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + result_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + result_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder(result_).mergeFrom(value).buildPartial(); + } else { + result_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression result = 2; + */ + public Builder clearResult() { + result_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch) + } + + static { + defaultInstance = new IrCatch(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch) + } + + public interface IrSyntheticBodyOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBodyKind kind = 1; + */ + boolean hasKind(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBodyKind kind = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind getKind(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody} + */ + public static final class IrSyntheticBody extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind kind_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBodyKind kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBodyKind kind = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind getKind() { + return kind_; + } + + private void initFields() { + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind.ENUM_VALUES; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind.ENUM_VALUES; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBodyKind kind = 1; + */ + public boolean hasKind() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBodyKind kind = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind getKind() { + return kind_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBodyKind kind = 1; + */ + public Builder setKind(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + kind_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBodyKind kind = 1; + */ + public Builder clearKind() { + bitField0_ = (bitField0_ & ~0x00000001); + kind_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBodyKind.ENUM_VALUES; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody) + } + + static { + defaultInstance = new IrSyntheticBody(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody) + } + + public interface IrStatementOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + boolean hasCoordinates(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + boolean hasDeclaration(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDeclaration(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + boolean hasExpression(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + boolean hasBlockBody(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody getBlockBody(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + boolean hasBranch(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch getBranch(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + boolean hasCatch(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch getCatch(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + boolean hasSyntheticBody(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody getSyntheticBody(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.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, 1); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFieldsCodedOutput, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = coordinates_.toBuilder(); + } + coordinates_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(coordinates_); + coordinates_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder subBuilder = null; + if (statementCase_ == 2) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 2; + break; + } + case 26: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder subBuilder = null; + if (statementCase_ == 3) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 3; + break; + } + case 34: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody.Builder subBuilder = null; + if (statementCase_ == 4) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 4; + break; + } + case 42: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch.Builder subBuilder = null; + if (statementCase_ == 5) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 5; + break; + } + case 50: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch.Builder subBuilder = null; + if (statementCase_ == 6) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch) statement_); + statement_ = subBuilder.buildPartial(); + } + statementCase_ = 6; + break; + } + case 58: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody.Builder subBuilder = null; + if (statementCase_ == 7) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody) statement_).toBuilder(); + } + statement_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates coordinates_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates() { + return coordinates_; + } + + public static final int DECLARATION_FIELD_NUMBER = 2; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + public boolean hasDeclaration() { + return statementCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDeclaration() { + if (statementCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + } + + public static final int EXPRESSION_FIELD_NUMBER = 3; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + public boolean hasExpression() { + return statementCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression() { + if (statementCase_ == 3) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + } + + public static final int BLOCK_BODY_FIELD_NUMBER = 4; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + public boolean hasBlockBody() { + return statementCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody getBlockBody() { + if (statementCase_ == 4) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody.getDefaultInstance(); + } + + public static final int BRANCH_FIELD_NUMBER = 5; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + public boolean hasBranch() { + return statementCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch getBranch() { + if (statementCase_ == 5) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch.getDefaultInstance(); + } + + public static final int CATCH_FIELD_NUMBER = 6; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + public boolean hasCatch() { + return statementCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch getCatch() { + if (statementCase_ == 6) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch.getDefaultInstance(); + } + + public static final int SYNTHETIC_BODY_FIELD_NUMBER = 7; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + public boolean hasSyntheticBody() { + return statementCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody getSyntheticBody() { + if (statementCase_ == 7) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody.getDefaultInstance(); + } + + private void initFields() { + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration) statement_); + } + if (statementCase_ == 3) { + output.writeMessage(3, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) statement_); + } + if (statementCase_ == 4) { + output.writeMessage(4, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody) statement_); + } + if (statementCase_ == 5) { + output.writeMessage(5, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch) statement_); + } + if (statementCase_ == 6) { + output.writeMessage(6, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch) statement_); + } + if (statementCase_ == 7) { + output.writeMessage(7, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration) statement_); + } + if (statementCase_ == 3) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) statement_); + } + if (statementCase_ == 4) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(4, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody) statement_); + } + if (statementCase_ == 5) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch) statement_); + } + if (statementCase_ == 6) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(6, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch) statement_); + } + if (statementCase_ == 7) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(7, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement parseFrom(byte[] data) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatementOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + statementCase_ = 0; + statement_ = null; + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrStatement parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.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.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + public boolean hasCoordinates() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates getCoordinates() { + return coordinates_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + public Builder setCoordinates(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates value) { + if (value == null) { + throw new NullPointerException(); + } + coordinates_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + public Builder setCoordinates( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.Builder builderForValue) { + coordinates_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + public Builder mergeCoordinates(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + coordinates_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance()) { + coordinates_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.newBuilder(coordinates_).mergeFrom(value).buildPartial(); + } else { + coordinates_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.Coordinates coordinates = 1; + */ + public Builder clearCoordinates() { + coordinates_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.Coordinates.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + public boolean hasDeclaration() { + return statementCase_ == 2; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration getDeclaration() { + if (statementCase_ == 2) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + public Builder setDeclaration(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + public Builder setDeclaration( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + public Builder mergeDeclaration(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration value) { + if (statementCase_ == 2 && + statement_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDeclaration) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 2; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDeclaration declaration = 2; + */ + public Builder clearDeclaration() { + if (statementCase_ == 2) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + public boolean hasExpression() { + return statementCase_ == 3; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getExpression() { + if (statementCase_ == 3) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + public Builder setExpression(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + public Builder setExpression( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + public Builder mergeExpression(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (statementCase_ == 3 && + statement_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 3; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression expression = 3; + */ + public Builder clearExpression() { + if (statementCase_ == 3) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + public boolean hasBlockBody() { + return statementCase_ == 4; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody getBlockBody() { + if (statementCase_ == 4) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + public Builder setBlockBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + public Builder setBlockBody( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + public Builder mergeBlockBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody value) { + if (statementCase_ == 4 && + statement_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBlockBody) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 4; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBlockBody block_body = 4; + */ + public Builder clearBlockBody() { + if (statementCase_ == 4) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + public boolean hasBranch() { + return statementCase_ == 5; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch getBranch() { + if (statementCase_ == 5) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + public Builder setBranch(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + public Builder setBranch( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + public Builder mergeBranch(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch value) { + if (statementCase_ == 5 && + statement_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrBranch) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 5; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrBranch branch = 5; + */ + public Builder clearBranch() { + if (statementCase_ == 5) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + public boolean hasCatch() { + return statementCase_ == 6; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch getCatch() { + if (statementCase_ == 6) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + public Builder setCatch(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + public Builder setCatch( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + public Builder mergeCatch(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch value) { + if (statementCase_ == 6 && + statement_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrCatch) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 6; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrCatch catch = 6; + */ + public Builder clearCatch() { + if (statementCase_ == 6) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + public boolean hasSyntheticBody() { + return statementCase_ == 7; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody getSyntheticBody() { + if (statementCase_ == 7) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody) statement_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + public Builder setSyntheticBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody value) { + if (value == null) { + throw new NullPointerException(); + } + statement_ = value; + + statementCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + public Builder setSyntheticBody( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody.Builder builderForValue) { + statement_ = builderForValue.build(); + + statementCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + public Builder mergeSyntheticBody(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody value) { + if (statementCase_ == 7 && + statement_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody.getDefaultInstance()) { + statement_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrSyntheticBody) statement_) + .mergeFrom(value).buildPartial(); + } else { + statement_ = value; + } + + statementCase_ = 7; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrSyntheticBody synthetic_body = 7; + */ + public Builder clearSyntheticBody() { + if (statementCase_ == 7) { + statementCase_ = 0; + statement_ = null; + + } + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement) + } + + static { + defaultInstance = new IrStatement(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrStatement) + } + + + static { + } + + // @@protoc_insertion_point(outer_class_scope) +} \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBufModuleDeserializer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBufModuleDeserializer.kt new file mode 100644 index 00000000000..49f9bf5fb8c --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrKlibProtoBufModuleDeserializer.kt @@ -0,0 +1,337 @@ +/* + * 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.LoggingContext +import org.jetbrains.kotlin.backend.common.descriptors.* +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.impl.EmptyPackageFragmentDescriptor +import org.jetbrains.kotlin.incremental.components.NoLookupLocation +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.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.name.Name +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( + currentModule: ModuleDescriptor, + logger: LoggingContext, + builtIns: IrBuiltIns, + libraryDir: File, + symbolTable: SymbolTable, + val forwardModuleDescriptor: ModuleDescriptor?) + : IrModuleDeserializer(logger, builtIns, symbolTable) { + + val deserializedSymbols = mutableMapOf() + val knownBuiltInsDescriptors = mutableMapOf() + val reachableTopLevels = mutableSetOf() + val deserializedTopLevels = mutableSetOf() + val forwardDeclarations = mutableSetOf() + + var deserializedModuleDescriptor: ModuleDescriptor? = null + var deserializedModuleProtoSymbolTables = mutableMapOf() + var deserializedModuleProtoTypeTables = mutableMapOf() + + val resolvedForwardDeclarations = mutableMapOf() + val descriptorReferenceDeserializer = DescriptorReferenceDeserializer(currentModule, resolvedForwardDeclarations) + + val moduleRoot = libraryDir + val irDirectory = File(libraryDir, "ir/") + + + private val FUNCTION_INDEX_START: Long + + init { + 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 -> + IrAnonymousInitializerSymbolImpl( + descriptor as ClassDescriptor? + ?: WrappedClassDescriptor() + ) + IrKlibProtoBuf.IrSymbolKind.CLASS_SYMBOL -> + symbolTable.referenceClass( + descriptor as ClassDescriptor? + ?: WrappedClassDescriptor() + ) + IrKlibProtoBuf.IrSymbolKind.CONSTRUCTOR_SYMBOL -> + symbolTable.referenceConstructor( + descriptor as ClassConstructorDescriptor? + ?: WrappedClassConstructorDescriptor() + ) + IrKlibProtoBuf.IrSymbolKind.TYPE_PARAMETER_SYMBOL -> + symbolTable.referenceTypeParameter( + descriptor as TypeParameterDescriptor? + ?: WrappedTypeParameterDescriptor() + ) + IrKlibProtoBuf.IrSymbolKind.ENUM_ENTRY_SYMBOL -> + symbolTable.referenceEnumEntry( + descriptor as ClassDescriptor? + ?: WrappedEnumEntryDescriptor() + ) + IrKlibProtoBuf.IrSymbolKind.STANDALONE_FIELD_SYMBOL -> + IrFieldSymbolImpl(WrappedFieldDescriptor()) + + IrKlibProtoBuf.IrSymbolKind.FIELD_SYMBOL -> + symbolTable.referenceField( + descriptor as PropertyDescriptor? + ?: WrappedPropertyDescriptor() + ) + IrKlibProtoBuf.IrSymbolKind.FUNCTION_SYMBOL -> + symbolTable.referenceSimpleFunction( + descriptor as FunctionDescriptor? + ?: WrappedSimpleFunctionDescriptor() + ) + IrKlibProtoBuf.IrSymbolKind.VARIABLE_SYMBOL -> + IrVariableSymbolImpl( + descriptor as VariableDescriptor? + ?: WrappedVariableDescriptor() + ) + IrKlibProtoBuf.IrSymbolKind.VALUE_PARAMETER_SYMBOL -> + IrValueParameterSymbolImpl( + descriptor as ParameterDescriptor? + ?: WrappedValueParameterDescriptor() + ) + IrKlibProtoBuf.IrSymbolKind.RECEIVER_PARAMETER_SYMBOL -> + IrValueParameterSymbolImpl( + descriptor as ParameterDescriptor? ?: WrappedReceiverParameterDescriptor() + ) + else -> TODO("Unexpected classifier symbol kind: ${proto.kind}") + } + + override fun deserializeIrSymbol(proto: IrKlibProtoBuf.IrSymbol): IrSymbol { + val symbolData = + deserializedModuleProtoSymbolTables[deserializedModuleDescriptor]!!.getSymbols(proto.index) + return deserializeIrSymbolData(symbolData) + } + + override fun deserializeIrType(proto: IrKlibProtoBuf.IrTypeIndex): IrType { + val typeData = + deserializedModuleProtoTypeTables[deserializedModuleDescriptor]!!.getTypes(proto.index) + return deserializeIrTypeData(typeData) + } + + fun deserializeIrSymbolData(proto: IrKlibProtoBuf.IrSymbolData): IrSymbol { + val key = proto.uniqId.uniqIdKey(deserializedModuleDescriptor!!) + val topLevelKey = proto.topLevelUniqId.uniqIdKey(deserializedModuleDescriptor!!) + + if (!deserializedTopLevels.contains(topLevelKey)) reachableTopLevels.add(topLevelKey) + + val symbol = deserializedSymbols.getOrPut(key) { + val descriptor = if (proto.hasDescriptorReference()) { + deserializeDescriptorReference(proto.descriptorReference) + } else { + null + } + + resolvedForwardDeclarations[key]?.let { + if (!deserializedTopLevels.contains(it)) reachableTopLevels.add(it) // Assuming forward declarations are always top levels. + } + + referenceDeserializedSymbol(proto, descriptor) + } + + if (symbol.descriptor is ClassDescriptor && + symbol.descriptor !is WrappedDeclarationDescriptor<*>/* && + symbol.descriptor.module.isForwardDeclarationModule*/ + ) { + forwardDeclarations.add(symbol) + } + + return symbol + } + + override fun deserializeDescriptorReference(proto: IrKlibProtoBuf.DescriptorReference) = + descriptorReferenceDeserializer.deserializeDescriptorReference(proto, { + knownBuiltInsDescriptors[it]?.index ?: if (isBuiltInFunction(it)) FUNCTION_INDEX_START + builtInFunctionId(it) else null + }, { (FUNCTION_INDEX_START + BUILT_IN_UNIQ_ID_CLASS_OFFSET) <= it && it < (FUNCTION_INDEX_START + BUILT_IN_UNIQ_ID_GAP) }, { + builtIns.builtIns.getBuiltInClassByFqName(it) + }) + + private val ByteArray.codedInputStream: org.jetbrains.kotlin.protobuf.CodedInputStream + get() { + val codedInputStream = org.jetbrains.kotlin.protobuf.CodedInputStream.newInstance(this) + codedInputStream.setRecursionLimit(65535) // The default 64 is blatantly not enough for IR. + return codedInputStream + } + + private val reversedFileIndex = mutableMapOf() + + private val UniqIdKey.moduleOfOrigin get() = + this.moduleDescriptor ?: reversedFileIndex[this]?.packageFragmentDescriptor?.containingDeclaration + + private fun deserializeTopLevelDeclaration(uniqIdKey: UniqIdKey): IrDeclaration { + val proto = loadTopLevelDeclarationProto(uniqIdKey) + return deserializeDeclaration(proto, reversedFileIndex[uniqIdKey]!!) + } + + private fun loadTopLevelDeclarationProto(uniqIdKey: UniqIdKey): IrKlibProtoBuf.IrDeclaration { + val file = File(irDirectory, uniqIdKey.uniqId.declarationFileName) + return IrKlibProtoBuf.IrDeclaration.parseFrom(file.readBytes().codedInputStream, JsKlibMetadataSerializerProtocol.extensionRegistry) + } + + private fun findDeserializedDeclarationForDescriptor(descriptor: DeclarationDescriptor): DeclarationDescriptor? { + val topLevelDescriptor = descriptor.findTopLevelDescriptor() + +// if (topLevelDescriptor.module.isForwardDeclarationModule) return null + + if (topLevelDescriptor !is DeserializedClassDescriptor && topLevelDescriptor !is DeserializedCallableMemberDescriptor) { + return null + } + + val descriptorUniqId = topLevelDescriptor.getUniqId() + ?: error("could not get descriptor uniq id for $topLevelDescriptor") + val uniqId = UniqId(descriptorUniqId.index, isLocal = false) + val topLevelKey = UniqIdKey(topLevelDescriptor.module, uniqId) + + // This top level descriptor doesn't have a serialized IR declaration. + if (topLevelKey.moduleOfOrigin == null) return null + + reachableTopLevels.add(topLevelKey) + + do { + val key = reachableTopLevels.first() + + if (deserializedSymbols[key]?.isBound == true || + // The key.moduleOrigin is null for uniqIds that we haven't seen in any of the library headers. + // Just skip it for now and handle it elsewhere. + key.moduleOfOrigin == null) { + + reachableTopLevels.remove(key) + deserializedTopLevels.add(key) + continue + } + + deserializedModuleDescriptor = key.moduleOfOrigin + val reachable = deserializeTopLevelDeclaration(key) + reversedFileIndex[key]!!.declarations.add(reachable) + + reachableTopLevels.remove(key) + deserializedTopLevels.add(key) + } while (reachableTopLevels.isNotEmpty()) + + return topLevelDescriptor + } + + override fun findDeserializedDeclaration(symbol: IrSymbol): IrDeclaration? { + + if (!symbol.isBound) { + val topLevelDesecriptor = findDeserializedDeclarationForDescriptor(symbol.descriptor) + if (topLevelDesecriptor == null) return null + } + + assert(symbol.isBound) { + "findDeserializedDeclaration: symbol ${symbol} is unbound, descriptor = ${symbol.descriptor}, hash = ${symbol.descriptor.hashCode()}" + } + + return symbol.owner as IrDeclaration + } + + override fun findDeserializedDeclaration(propertyDescriptor: PropertyDescriptor): IrProperty? { + val topLevelDesecriptor = findDeserializedDeclarationForDescriptor(propertyDescriptor) + if (topLevelDesecriptor == null) return null + + return symbolTable.propertyTable[propertyDescriptor] + ?: error("findDeserializedDeclaration: property descriptor $propertyDescriptor} is not present in propertyTable after deserialization}") + } + + override fun declareForwardDeclarations() { + if (forwardModuleDescriptor == null) return + + val packageFragments = forwardDeclarations.map { it.descriptor.findPackage() }.distinct() + + // We don't bother making a real IR module here, as we have no need in it any later. + // All we need is just to declare forward declarations in the symbol table + // In case you need a full fledged module, turn the forEach into a map and collect + // produced files into an IrModuleFragment. + + packageFragments.forEach { packageFragment -> + val symbol = IrFileSymbolImpl(packageFragment) + val file = IrFileImpl(NaiveSourceBasedFileEntryImpl("forward declarations pseudo-file"), symbol) + val symbols = forwardDeclarations + .filter { !it.isBound } + .filter { it.descriptor.findPackage() == packageFragment } + val declarations = symbols.map { + + val classDescriptor = it.descriptor as ClassDescriptor + val declaration = symbolTable.declareClass(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irrelevantOrigin, + classDescriptor, + classDescriptor.modality + ) { symbol: IrClassSymbol -> IrClassImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irrelevantOrigin, symbol) } + declaration + + } + file.declarations.addAll(declarations) + } + } + + fun deserializeIrFile(fileProto: IrKlibProtoBuf.IrFile, moduleDescriptor: ModuleDescriptor, deserializeAllDeclarations: Boolean): IrFile { + val fileEntry = NaiveSourceBasedFileEntryImpl(fileProto.fileEntry.name) + + // TODO: we need to store "" in protobuf, I suppose. Or better yet, reuse fqname storage from metadata. + val fqName = if (fileProto.fqName == "") FqName.ROOT else FqName(fileProto.fqName) + + val packageFragmentDescriptor = EmptyPackageFragmentDescriptor(moduleDescriptor, fqName) + + val symbol = IrFileSymbolImpl(packageFragmentDescriptor) + val file = IrFileImpl(fileEntry, symbol, fqName) + + fileProto.declarationIdList.forEach { + val uniqIdKey = it.uniqIdKey(moduleDescriptor) + reversedFileIndex.put(uniqIdKey, file) + + if (deserializeAllDeclarations) { + file.declarations.add(deserializeTopLevelDeclaration(uniqIdKey)) + } + } + + return file + } + + fun deserializeIrModule(proto: IrKlibProtoBuf.IrModule, moduleDescriptor: ModuleDescriptor, deserializeAllDeclarations: Boolean): IrModuleFragment { + + deserializedModuleDescriptor = moduleDescriptor + deserializedModuleProtoSymbolTables.put(moduleDescriptor, proto.symbolTable) + deserializedModuleProtoTypeTables.put(moduleDescriptor, proto.typeTable) + + var i = 0 + val files = proto.fileList.map { + i++ +// if (i >= 41) +// descriptorReferenceDeserializer.doCrash = true + deserializeIrFile(it, moduleDescriptor, deserializeAllDeclarations) + } + val module = IrModuleFragmentImpl(moduleDescriptor, builtIns, files) + module.patchDeclarationParents(null) + return module + } + + fun deserializeIrModule(moduleDescriptor: ModuleDescriptor, byteArray: ByteArray, deserializeAllDeclarations: Boolean = false): IrModuleFragment { + val proto = IrKlibProtoBuf.IrModule.parseFrom(byteArray.codedInputStream, JsKlibMetadataSerializerProtocol.extensionRegistry) + return deserializeIrModule(proto, moduleDescriptor, deserializeAllDeclarations) + } +} \ 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.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleDeserializer.kt new file mode 100644 index 00000000000..d967af3665a --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleDeserializer.kt @@ -0,0 +1,1131 @@ +/* + * 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.LoggingContext +import org.jetbrains.kotlin.backend.common.descriptors.* +import org.jetbrains.kotlin.backend.common.ir.DeclarationFactory +import org.jetbrains.kotlin.backend.common.ir.ir2string +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.IrStatement +import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +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.* +import org.jetbrains.kotlin.ir.expressions.impl.* +import org.jetbrains.kotlin.ir.symbols.* +import org.jetbrains.kotlin.ir.types.* +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.name.Name +import org.jetbrains.kotlin.types.Variance + +// TODO: This code still has some uses of descriptors: +// 1. We use descriptors as keys for symbolTable -- probably symbol table related code should be refactored out from +// the deserializer. +// 2. Properties use descriptors but not symbols -- that causes lots of assymmetry all around. +// 3. Declarations are provided with wrapped descriptors. That is probably a legitimate descriptor use. + +abstract class IrModuleDeserializer( + val logger: LoggingContext, + val builtIns: IrBuiltIns, + 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 + + private fun deserializeTypeArguments(proto: IrKlibProtoBuf.TypeArguments): List { + logger.log { "### deserializeTypeArguments" } + val result = mutableListOf() + proto.typeArgumentList.forEach { typeProto -> + val type = deserializeIrType(typeProto) + result.add(type) + logger.log { "$type" } + } + 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 deserializeIrTypeArgument(proto: IrKlibProtoBuf.IrTypeArgument) = when (proto.kindCase) { + IrKlibProtoBuf.IrTypeArgument.KindCase.STAR -> IrStarProjectionImpl + IrKlibProtoBuf.IrTypeArgument.KindCase.TYPE -> makeTypeProjection( + deserializeIrType(proto.type.type), deserializeIrTypeVariance(proto.type.variance) + ) + else -> TODO("Unexpected projection kind") + + } + + fun deserializeAnnotations(annotations: IrKlibProtoBuf.Annotations): List { + return annotations.annotationList.map { + deserializeCall(it, 0, 0, builtIns.unitType) // TODO: need a proper deserialization here + } + } + + fun deserializeSimpleType(proto: IrKlibProtoBuf.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 arguments = proto.argumentList.map { deserializeIrTypeArgument(it) } + val annotations = deserializeAnnotations(proto.annotations) + IrSimpleTypeImpl( + null, + symbol, + proto.hasQuestionMark, + arguments, + annotations + ) + } + logger.log { "ir_type = $result; render = ${result.render()}" } + return result + + } + + fun deserializeDynamicType(proto: IrKlibProtoBuf.IrDynamicType): IrDynamicType { + val annotations = deserializeAnnotations(proto.annotations) + return IrDynamicTypeImpl(null, annotations, Variance.INVARIANT) + } + + fun deserializeErrorType(proto: IrKlibProtoBuf.IrErrorType): IrErrorType { + val annotations = deserializeAnnotations(proto.annotations) + return IrErrorTypeImpl(null, annotations, Variance.INVARIANT) + } + + fun deserializeIrTypeData(proto: IrKlibProtoBuf.IrType): IrType { + return when (proto.kindCase) { + SIMPLE -> deserializeSimpleType(proto.simple) + DYNAMIC -> deserializeDynamicType(proto.dynamic) + ERROR -> deserializeErrorType(proto.error) + else -> TODO("Unexpected IrType kind: ${proto.kindCase}") + } + } + + /* -------------------------------------------------------------- */ + + private fun deserializeBlockBody( + proto: IrKlibProtoBuf.IrBlockBody, + start: Int, end: Int + ): IrBlockBody { + + val statements = mutableListOf() + + val statementProtos = proto.statementList + statementProtos.forEach { + statements.add(deserializeStatement(it) as IrStatement) + } + + return IrBlockBodyImpl(start, end, statements) + } + + private fun deserializeBranch(proto: IrKlibProtoBuf.IrBranch, start: Int, end: Int): IrBranch { + + val condition = deserializeExpression(proto.condition) + val result = deserializeExpression(proto.result) + + return IrBranchImpl(start, end, condition, result) + } + + private fun deserializeCatch(proto: IrKlibProtoBuf.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) + + val catch = IrCatchImpl(start, end, catchParameter, result) + return catch + } + + private fun deserializeSyntheticBody(proto: IrKlibProtoBuf.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 + } + return IrSyntheticBodyImpl(start, end, kind) + } + + private fun deserializeStatement(proto: IrKlibProtoBuf.IrStatement): IrElement { + val start = proto.coordinates.startOffset + val end = proto.coordinates.endOffset + val element = when (proto.statementCase) { + StatementCase.BLOCK_BODY //proto.hasBlockBody() + -> deserializeBlockBody(proto.blockBody, start, end) + StatementCase.BRANCH //proto.hasBranch() + -> deserializeBranch(proto.branch, start, end) + StatementCase.CATCH //proto.hasCatch() + -> deserializeCatch(proto.catch, start, end) + StatementCase.DECLARATION // proto.hasDeclaration() + -> deserializeDeclaration(proto.declaration, null) // TODO: we need a proper parent here. + StatementCase.EXPRESSION // proto.hasExpression() + -> deserializeExpression(proto.expression) + StatementCase.SYNTHETIC_BODY // proto.hasSyntheticBody() + -> deserializeSyntheticBody(proto.syntheticBody, start, end) + else + -> TODO("Statement deserialization not implemented: ${proto.statementCase}") + } + + logger.log { "### Deserialized statement: ${ir2string(element)}" } + + return element + } + + private fun deserializeBlock(proto: IrKlibProtoBuf.IrBlock, start: Int, end: Int, type: IrType): IrBlock { + val statements = mutableListOf() + val statementProtos = proto.statementList + statementProtos.forEach { + statements.add(deserializeStatement(it) as IrStatement) + } + + val isLambdaOrigin = if (proto.isLambdaOrigin) IrStatementOrigin.LAMBDA else null + + return IrBlockImpl(start, end, type, isLambdaOrigin, statements) + } + + private fun deserializeMemberAccessCommon(access: IrMemberAccessExpression, proto: IrKlibProtoBuf.MemberAccessCommon) { + + proto.valueArgumentList.mapIndexed { i, arg -> + if (arg.hasExpression()) { + val expr = deserializeExpression(arg.expression) + access.putValueArgument(i, expr) + } + } + + deserializeTypeArguments(proto.typeArguments).forEachIndexed { index, type -> + access.putTypeArgument(index, type) + } + + if (proto.hasDispatchReceiver()) { + access.dispatchReceiver = deserializeExpression(proto.dispatchReceiver) + } + if (proto.hasExtensionReceiver()) { + access.extensionReceiver = deserializeExpression(proto.extensionReceiver) + } + } + + private fun deserializeClassReference( + proto: IrKlibProtoBuf.IrClassReference, + start: Int, + end: Int, + type: IrType + ): IrClassReference { + val symbol = deserializeIrSymbol(proto.classSymbol) as IrClassifierSymbol + val classType = deserializeIrType(proto.classType) + /** TODO: [createClassifierSymbolForClassReference] is internal function */ + return IrClassReferenceImpl(start, end, type, symbol, classType) + } + + private fun deserializeCall(proto: IrKlibProtoBuf.IrCall, start: Int, end: Int, type: IrType): IrCall { + val symbol = deserializeIrSymbol(proto.symbol) as IrFunctionSymbol + + val superSymbol = if (proto.hasSuper()) { + deserializeIrSymbol(proto.`super`) as IrClassSymbol + } else null + + val call: IrCall = when (proto.kind) { + IrKlibProtoBuf.IrCall.Primitive.NOT_PRIMITIVE -> + // TODO: implement the last three args here. + IrCallImpl( + start, end, type, + symbol, symbol.descriptor, + proto.memberAccess.typeArguments.typeArgumentCount, + proto.memberAccess.valueArgumentList.size, + null, superSymbol + ) + IrKlibProtoBuf.IrCall.Primitive.NULLARY -> + IrNullaryPrimitiveImpl(start, end, type, null, symbol) + IrKlibProtoBuf.IrCall.Primitive.UNARY -> + IrUnaryPrimitiveImpl(start, end, type, null, symbol) + IrKlibProtoBuf.IrCall.Primitive.BINARY -> + IrBinaryPrimitiveImpl(start, end, type, null, symbol) + else -> TODO("Unexpected primitive IrCall.") + } + deserializeMemberAccessCommon(call, proto.memberAccess) + return call + } + + private fun deserializeComposite(proto: IrKlibProtoBuf.IrComposite, start: Int, end: Int, type: IrType): IrComposite { + val statements = mutableListOf() + val statementProtos = proto.statementList + statementProtos.forEach { + statements.add(deserializeStatement(it) as IrStatement) + } + return IrCompositeImpl(start, end, type, null, statements) + } + + private fun deserializeDelegatingConstructorCall( + proto: IrKlibProtoBuf.IrDelegatingConstructorCall, + start: Int, + end: Int + ): IrDelegatingConstructorCall { + val symbol = deserializeIrSymbol(proto.symbol) as IrConstructorSymbol + val call = IrDelegatingConstructorCallImpl( + start, + end, + builtIns.unitType, + symbol, + symbol.descriptor, + proto.memberAccess.typeArguments.typeArgumentCount, + proto.memberAccess.valueArgumentList.size + ) + + deserializeMemberAccessCommon(call, proto.memberAccess) + return call + } + + + fun deserializeEnumConstructorCall( + proto: IrKlibProtoBuf.IrEnumConstructorCall, + start: Int, + end: Int, + type: IrType + ): IrEnumConstructorCall { + val symbol = deserializeIrSymbol(proto.symbol) as IrConstructorSymbol + val call = IrEnumConstructorCallImpl( + start, + end, + type, + symbol, + proto.memberAccess.typeArguments.typeArgumentList.size, + proto.memberAccess.valueArgumentList.size + ) + deserializeMemberAccessCommon(call, proto.memberAccess) + return call + } + + + private fun deserializeFunctionReference( + proto: IrKlibProtoBuf.IrFunctionReference, + start: Int, end: Int, type: IrType + ): IrFunctionReference { + + val symbol = deserializeIrSymbol(proto.symbol) as IrFunctionSymbol + val callable = IrFunctionReferenceImpl( + start, + end, + type, + symbol, + symbol.descriptor, + proto.memberAccess.typeArguments.typeArgumentCount, + proto.memberAccess.valueArgumentCount, + null + ) + deserializeMemberAccessCommon(callable, proto.memberAccess) + + return callable + } + + private fun deserializeGetClass(proto: IrKlibProtoBuf.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 { + val access = proto.fieldAccess + val symbol = deserializeIrSymbol(access.symbol) as IrFieldSymbol + val superQualifier = if (access.hasSuper()) { + deserializeIrSymbol(access.symbol) as IrClassSymbol + } else null + val receiver = if (access.hasReceiver()) { + deserializeExpression(access.receiver) + } else null + + return IrGetFieldImpl(start, end, symbol, type, receiver, null, superQualifier) + } + + private fun deserializeGetValue(proto: IrKlibProtoBuf.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 { + 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 { + val symbol = deserializeIrSymbol(proto.symbol) as IrClassSymbol + return IrGetObjectValueImpl(start, end, type, symbol) + } + + private fun deserializeInstanceInitializerCall( + proto: IrKlibProtoBuf.IrInstanceInitializerCall, + start: Int, + end: Int + ): IrInstanceInitializerCall { + val symbol = deserializeIrSymbol(proto.symbol) as IrClassSymbol + return IrInstanceInitializerCallImpl(start, end, symbol, builtIns.unitType) + } + + private fun deserializePropertyReference( + proto: IrKlibProtoBuf.IrPropertyReference, + start: Int, end: Int, type: IrType + ): IrPropertyReference { + + val field = if (proto.hasField()) deserializeIrSymbol(proto.field) as IrFieldSymbol else null + val getter = if (proto.hasGetter()) deserializeIrSymbol(proto.getter) as IrSimpleFunctionSymbol else null + val setter = if (proto.hasSetter()) deserializeIrSymbol(proto.setter) as IrSimpleFunctionSymbol else null + val descriptor = WrappedPropertyDescriptor() + + val callable = IrPropertyReferenceImpl( + start, end, type, + descriptor, + proto.memberAccess.typeArguments.typeArgumentCount, + field, + getter, + setter, + null + ) + deserializeMemberAccessCommon(callable, proto.memberAccess) + return callable + } + + private fun deserializeReturn(proto: IrKlibProtoBuf.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 { + val access = proto.fieldAccess + val symbol = deserializeIrSymbol(access.symbol) as IrFieldSymbol + val superQualifier = if (access.hasSuper()) { + deserializeIrSymbol(access.symbol) as IrClassSymbol + } else null + val receiver = if (access.hasReceiver()) { + deserializeExpression(access.receiver) + } else null + val value = deserializeExpression(proto.value) + + return IrSetFieldImpl(start, end, symbol, receiver, value, builtIns.unitType, null, superQualifier) + } + + private fun deserializeSetVariable(proto: IrKlibProtoBuf.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 { + val expression = deserializeExpression(proto.expression) + return IrSpreadElementImpl(proto.coordinates.startOffset, proto.coordinates.endOffset, expression) + } + + private fun deserializeStringConcat( + proto: IrKlibProtoBuf.IrStringConcat, + start: Int, + end: Int, + type: IrType + ): IrStringConcatenation { + val argumentProtos = proto.argumentList + val arguments = mutableListOf() + + argumentProtos.forEach { + arguments.add(deserializeExpression(it)) + } + return IrStringConcatenationImpl(start, end, type, arguments) + } + + private fun deserializeThrow(proto: IrKlibProtoBuf.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 { + val result = deserializeExpression(proto.result) + val catches = mutableListOf() + proto.catchList.forEach { + catches.add(deserializeStatement(it) as IrCatch) + } + val finallyExpression = + if (proto.hasFinally()) deserializeExpression(proto.getFinally()) else null + return IrTryImpl(start, end, type, result, catches, finallyExpression) + } + + private fun deserializeTypeOperator(operator: IrKlibProtoBuf.IrTypeOperator) = when (operator) { + IrKlibProtoBuf.IrTypeOperator.CAST + -> IrTypeOperator.CAST + IrKlibProtoBuf.IrTypeOperator.IMPLICIT_CAST + -> IrTypeOperator.IMPLICIT_CAST + IrKlibProtoBuf.IrTypeOperator.IMPLICIT_NOTNULL + -> IrTypeOperator.IMPLICIT_NOTNULL + IrKlibProtoBuf.IrTypeOperator.IMPLICIT_COERCION_TO_UNIT + -> IrTypeOperator.IMPLICIT_COERCION_TO_UNIT + IrKlibProtoBuf.IrTypeOperator.IMPLICIT_INTEGER_COERCION + -> IrTypeOperator.IMPLICIT_INTEGER_COERCION + IrKlibProtoBuf.IrTypeOperator.SAFE_CAST + -> IrTypeOperator.SAFE_CAST + IrKlibProtoBuf.IrTypeOperator.INSTANCEOF + -> IrTypeOperator.INSTANCEOF + IrKlibProtoBuf.IrTypeOperator.NOT_INSTANCEOF + -> IrTypeOperator.NOT_INSTANCEOF + IrKlibProtoBuf.IrTypeOperator.SAM_CONVERSION + -> IrTypeOperator.SAM_CONVERSION + } + + private fun deserializeTypeOp(proto: IrKlibProtoBuf.IrTypeOp, start: Int, end: Int, type: IrType): IrTypeOperatorCall { + val operator = deserializeTypeOperator(proto.operator) + val operand = deserializeIrType(proto.operand)//.brokenIr + val argument = deserializeExpression(proto.argument) + return IrTypeOperatorCallImpl(start, end, type, operator, operand).apply { + this.argument = argument + this.typeOperandClassifier = operand.classifierOrFail + } + } + + private fun deserializeVararg(proto: IrKlibProtoBuf.IrVararg, start: Int, end: Int, type: IrType): IrVararg { + val elementType = deserializeIrType(proto.elementType) + + val elements = mutableListOf() + proto.elementList.forEach { + elements.add(deserializeVarargElement(it)) + } + return IrVarargImpl(start, end, type, elementType, elements) + } + + private fun deserializeVarargElement(element: IrKlibProtoBuf.IrVarargElement): IrVarargElement { + return when (element.varargElementCase) { + IrKlibProtoBuf.IrVarargElement.VarargElementCase.EXPRESSION + -> deserializeExpression(element.expression) + IrKlibProtoBuf.IrVarargElement.VarargElementCase.SPREAD_ELEMENT + -> deserializeSpreadElement(element.spreadElement) + else + -> TODO("Unexpected vararg element") + } + } + + private fun deserializeWhen(proto: IrKlibProtoBuf.IrWhen, start: Int, end: Int, type: IrType): IrWhen { + val branches = mutableListOf() + + proto.branchList.forEach { + branches.add(deserializeStatement(it) as IrBranch) + } + + // TODO: provide some origin! + 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 } + + val label = if (proto.hasLabel()) proto.label else null + val body = if (proto.hasBody()) deserializeExpression(proto.body) else null + val condition = deserializeExpression(proto.condition) + + loop.label = label + loop.condition = condition + loop.body = body + + 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 + } + + 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 deserializeBreak(proto: IrKlibProtoBuf.IrBreak, start: Int, end: Int, type: IrType): IrBreak { + val label = if (proto.hasLabel()) proto.label else null + val loopId = proto.loopId + val loop = loopIndex[loopId]!! + 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 { + val label = if (proto.hasLabel()) proto.label else null + val loopId = proto.loopId + val loop = loopIndex[loopId]!! + 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 = + when (proto.valueCase) { + NULL + -> IrConstImpl.constNull(start, end, type) + BOOLEAN + -> IrConstImpl.boolean(start, end, type, proto.boolean) + BYTE + -> IrConstImpl.byte(start, end, type, proto.byte.toByte()) + CHAR + -> IrConstImpl.char(start, end, type, proto.char.toChar()) + SHORT + -> IrConstImpl.short(start, end, type, proto.short.toShort()) + INT + -> IrConstImpl.int(start, end, type, proto.int) + LONG + -> IrConstImpl.long(start, end, type, proto.long) + STRING + -> IrConstImpl.string(start, end, type, proto.string) + FLOAT + -> IrConstImpl.float(start, end, type, proto.float) + DOUBLE + -> IrConstImpl.double(start, end, type, proto.double) + VALUE_NOT_SET + -> error("Const deserialization error: ${proto.valueCase} ") + } + + private fun deserializeOperation(proto: IrKlibProtoBuf.IrOperation, start: Int, end: Int, type: IrType): IrExpression = + when (proto.operationCase) { + BLOCK + -> deserializeBlock(proto.block, start, end, type) + BREAK + -> deserializeBreak(proto.`break`, start, end, type) + CLASS_REFERENCE + -> deserializeClassReference(proto.classReference, start, end, type) + CALL + -> deserializeCall(proto.call, start, end, type) + COMPOSITE + -> deserializeComposite(proto.composite, start, end, type) + CONST + -> deserializeConst(proto.const, start, end, type) + CONTINUE + -> deserializeContinue(proto.`continue`, start, end, type) + DELEGATING_CONSTRUCTOR_CALL + -> deserializeDelegatingConstructorCall(proto.delegatingConstructorCall, start, end) + DO_WHILE + -> deserializeDoWhile(proto.doWhile, start, end, type) + ENUM_CONSTRUCTOR_CALL + -> deserializeEnumConstructorCall(proto.enumConstructorCall, start, end, type) + FUNCTION_REFERENCE + -> deserializeFunctionReference(proto.functionReference, start, end, type) + GET_ENUM_VALUE + -> deserializeGetEnumValue(proto.getEnumValue, start, end, type) + GET_CLASS + -> deserializeGetClass(proto.getClass, start, end, type) + GET_FIELD + -> deserializeGetField(proto.getField, start, end, type) + GET_OBJECT + -> deserializeGetObject(proto.getObject, start, end, type) + GET_VALUE + -> deserializeGetValue(proto.getValue, start, end, type) + INSTANCE_INITIALIZER_CALL + -> deserializeInstanceInitializerCall(proto.instanceInitializerCall, start, end) + PROPERTY_REFERENCE + -> deserializePropertyReference(proto.propertyReference, start, end, type) + RETURN + -> deserializeReturn(proto.`return`, start, end, type) + SET_FIELD + -> deserializeSetField(proto.setField, start, end) + SET_VARIABLE + -> deserializeSetVariable(proto.setVariable, start, end) + STRING_CONCAT + -> deserializeStringConcat(proto.stringConcat, start, end, type) + THROW + -> deserializeThrow(proto.`throw`, start, end, type) + TRY + -> deserializeTry(proto.`try`, start, end, type) + TYPE_OP + -> deserializeTypeOp(proto.typeOp, start, end, type) + VARARG + -> deserializeVararg(proto.vararg, start, end, type) + WHEN + -> deserializeWhen(proto.`when`, start, end, type) + WHILE + -> deserializeWhile(proto.`while`, start, end, type) + OPERATION_NOT_SET + -> error("Expression deserialization not implemented: ${proto.operationCase}") + } + + private fun deserializeExpression(proto: IrKlibProtoBuf.IrExpression): IrExpression { + val start = proto.coordinates.startOffset + val end = proto.coordinates.endOffset + val type = deserializeIrType(proto.type) + val operation = proto.operation + val expression = deserializeOperation(operation, start, end, type) + + logger.log { "### Deserialized expression: ${ir2string(expression)} ir_type=$type" } + return expression + } + + private fun deserializeIrTypeParameter( + proto: IrKlibProtoBuf.IrTypeParameter, + start: Int, + end: Int, + origin: IrDeclarationOrigin + ): IrTypeParameter { + val symbol = deserializeIrSymbol(proto.symbol) as IrTypeParameterSymbol + val name = Name.identifier(proto.name) + val variance = deserializeIrTypeVariance(proto.variance) + + val parameter = symbolTable.declareGlobalTypeParameter(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irrelevantOrigin, + symbol.descriptor, { symbol -> + IrTypeParameterImpl(start, end, origin, symbol, name, proto.index, proto.isReified, variance) + } + ) + + val superTypes = proto.superTypeList.map { deserializeIrType(it) } + parameter.superTypes.addAll(superTypes) + + return parameter + } + + private fun deserializeIrTypeParameterContainer( + proto: IrKlibProtoBuf.IrTypeParameterContainer, + parent: IrDeclarationParent + ): List { + return proto.typeParameterList.map { + deserializeDeclaration( + it, + parent + ) as IrTypeParameter + } // 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 deserializeIrValueParameter( + proto: IrKlibProtoBuf.IrValueParameter, + start: Int, + end: Int, + origin: IrDeclarationOrigin + ): IrValueParameter { + + val varargElementType = if (proto.hasVarargElementType()) deserializeIrType(proto.varargElementType) else null + val paramSymbol = deserializeIrSymbol(proto.symbol) as IrValueParameterSymbol + val parameter = + IrValueParameterImpl( + start, end, origin, + paramSymbol, + proto.name.let { if (paramSymbol.descriptor is ReceiverParameterDescriptor) Name.special(it) else Name.identifier(it) }, + proto.index, + deserializeIrType(proto.type), + varargElementType, + proto.isCrossinline, + proto.isNoinline + ).apply { + defaultValue = if (proto.hasDefaultValue()) { + val expression = deserializeExpression(proto.defaultValue) + IrExpressionBodyImpl(expression) + } else null + } + + return parameter + } + + private fun deserializeIrClass(proto: IrKlibProtoBuf.IrClass, start: Int, end: Int, origin: IrDeclarationOrigin): IrClass { + + val symbol = deserializeIrSymbol(proto.symbol) as IrClassSymbol + + val modality = deserializeModality(proto.modality) + val clazz = symbolTable.declareClass(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irrelevantOrigin, + symbol.descriptor, modality) { symbol -> + IrClassImpl( + start, end, origin, + symbol, + proto.name.let { if (it.startsWith('<')) Name.special(it) else Name.identifier(it) }, + deserializeClassKind(proto.kind), + deserializeVisibility(proto.visibility), + modality, + proto.isCompanion, + proto.isInner, + proto.isData, + proto.isExternal, + proto.isInline + ) + } + + proto.declarationContainer.declarationList.forEach { + val member = deserializeDeclaration(it, clazz) + clazz.addMember(member) + member.parent = clazz + } + + clazz.thisReceiver = deserializeDeclaration(proto.thisReceiver, clazz) as IrValueParameter + + val typeParameters = deserializeIrTypeParameterContainer(proto.typeParameters, clazz) + clazz.typeParameters.addAll(typeParameters) + + val superTypes = proto.superTypeList.map { deserializeIrType(it) } + clazz.superTypes.addAll(superTypes) + + return clazz + } + + private fun deserializeIrFunctionBase( + base: IrKlibProtoBuf.IrFunctionBase, + function: IrFunctionBase, + start: Int, + end: Int, + origin: IrDeclarationOrigin + ) { + + function.body = if (base.hasBody()) deserializeStatement(base.body) as IrBody else null + + val valueParameters = base.valueParameterList.map { deserializeDeclaration(it, function) as IrValueParameter } + function.valueParameters.addAll(valueParameters) + function.dispatchReceiverParameter = if (base.hasDispatchReceiver()) deserializeDeclaration( + base.dispatchReceiver, + function + ) as IrValueParameter else null + function.extensionReceiverParameter = if (base.hasExtensionReceiver()) deserializeDeclaration( + base.extensionReceiver, + function + ) as IrValueParameter else null + val typeParameters = deserializeIrTypeParameterContainer(base.typeParameters, function) // TODO + function.typeParameters.addAll(typeParameters) + } + + private fun deserializeIrFunction( + proto: IrKlibProtoBuf.IrFunction, + start: Int, end: Int, origin: IrDeclarationOrigin, correspondingProperty: IrProperty? = null + ): IrSimpleFunction { + + logger.log { "### deserializing IrFunction ${proto.base.name}" } + val symbol = deserializeIrSymbol(proto.symbol) as IrSimpleFunctionSymbol + + val function = symbolTable.declareSimpleFunction(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irrelevantOrigin, + symbol.descriptor, { + IrFunctionImpl( + start, end, origin, it, + proto.base.name.let { if (correspondingProperty != null) Name.special(it) else Name.identifier(it) }, + deserializeVisibility(proto.base.visibility), + deserializeModality(proto.modality), + deserializeIrType(proto.base.returnType), + proto.base.isInline, + proto.base.isExternal, + proto.isTailrec, + proto.isSuspend + ) + }) + + deserializeIrFunctionBase(proto.base, function as IrFunctionBase, start, end, origin) + val overridden = proto.overriddenList.map { deserializeIrSymbol(it) as IrSimpleFunctionSymbol } + function.overriddenSymbols.addAll(overridden) + + function.correspondingProperty = correspondingProperty + + return function + } + + private fun deserializeIrVariable( + proto: IrKlibProtoBuf.IrVariable, + start: Int, end: Int, origin: IrDeclarationOrigin + ): IrVariable { + + val initializer = if (proto.hasInitializer()) { + deserializeExpression(proto.initializer) + } else null + + val symbol = deserializeIrSymbol(proto.symbol) as IrVariableSymbol + val type = deserializeIrType(proto.type) + + val variable = IrVariableImpl( + start, + end, + origin, + symbol, + Name.identifier(proto.name), + type, + proto.isVar, + proto.isConst, + proto.isLateinit + ) + variable.initializer = initializer + return variable + } + + private fun deserializeIrEnumEntry( + proto: IrKlibProtoBuf.IrEnumEntry, + start: Int, end: Int, origin: IrDeclarationOrigin + ): IrEnumEntry { + val symbol = deserializeIrSymbol(proto.symbol) as IrEnumEntrySymbol + + val enumEntry = symbolTable.declareEnumEntry( + UNDEFINED_OFFSET, + UNDEFINED_OFFSET, + irrelevantOrigin, + symbol.descriptor + ) { + IrEnumEntryImpl(start, end, origin, it, Name.identifier(proto.name)) + } + + if (proto.hasCorrespondingClass()) { + enumEntry.correspondingClass = deserializeDeclaration(proto.correspondingClass, null) as IrClass + } + if (proto.hasInitializer()) { + enumEntry.initializerExpression = deserializeExpression(proto.initializer) + } + + return enumEntry + } + + private fun deserializeIrAnonymousInit( + proto: IrKlibProtoBuf.IrAnonymousInit, + start: Int, + end: Int, + origin: IrDeclarationOrigin + ): IrAnonymousInitializer { + val symbol = deserializeIrSymbol(proto.symbol) as IrAnonymousInitializerSymbol + val initializer = IrAnonymousInitializerImpl(start, end, origin, symbol) + initializer.body = deserializeBlockBody(proto.body.blockBody, start, end) + return initializer + } + + private fun deserializeVisibility(value: String): Visibility { // TODO: switch to enum + return when (value) { + "public" -> Visibilities.PUBLIC + "private" -> Visibilities.PRIVATE + "private_to_this" -> Visibilities.PRIVATE_TO_THIS + "protected" -> Visibilities.PROTECTED + "internal" -> Visibilities.INTERNAL + "invisible_fake" -> Visibilities.INVISIBLE_FAKE // TODO: eventually we should not serialize fake overrides, so this will be gone. + "local" -> Visibilities.LOCAL + else -> error("Unexpected visibility value: $value") + } + } + + private fun deserializeIrConstructor( + proto: IrKlibProtoBuf.IrConstructor, + start: Int, + end: Int, + origin: IrDeclarationOrigin + ): IrConstructor { + val symbol = deserializeIrSymbol(proto.symbol) as IrConstructorSymbol + + val constructor = symbolTable.declareConstructor(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irrelevantOrigin, + symbol.descriptor, { + IrConstructorImpl( + start, end, origin, + it, + Name.special(proto.base.name), + deserializeVisibility(proto.base.visibility), + deserializeIrType(proto.base.returnType), + proto.base.isInline, + proto.base.isExternal, + proto.isPrimary + ) + + }) + + deserializeIrFunctionBase(proto.base, constructor as IrFunctionBase, start, end, origin) + return constructor + } + + private fun deserializeIrField(proto: IrKlibProtoBuf.IrField, start: Int, end: Int, origin: IrDeclarationOrigin): IrField { + + val symbol = deserializeIrSymbol(proto.symbol) as IrFieldSymbol + val type = deserializeIrType(proto.type) + val field = symbolTable.declareField(UNDEFINED_OFFSET, + UNDEFINED_OFFSET, + irrelevantOrigin, + symbol.descriptor, + type, + { IrFieldImpl( + start, end, origin, + it, + Name.identifier(proto.name), + type, + deserializeVisibility(proto.visibility), + proto.isFinal, + proto.isExternal, + proto.isStatic + ) + } + ) + + val initializer = if (proto.hasInitializer()) deserializeExpression(proto.initializer) else null + field.initializer = initializer?.let { IrExpressionBodyImpl(it) } + + 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 deserializeIrProperty( + proto: IrKlibProtoBuf.IrProperty, + start: Int, + end: Int, + origin: IrDeclarationOrigin + ): IrProperty { + + val backingField = if (proto.hasBackingField()) { + deserializeIrField(proto.backingField, start, end, origin) + } else null + + val descriptor = + if (proto.hasDescriptor()) deserializeDescriptorReference(proto.descriptor) as PropertyDescriptor else null + ?: WrappedPropertyDescriptor() + + val property = IrPropertyImpl( + start, end, origin, + descriptor, + Name.identifier(proto.name), + deserializeVisibility(proto.visibility), + deserializeModality(proto.modality), + proto.isVar, + proto.isConst, + proto.isLateinit, + proto.isDelegated, + proto.isExternal + ) + + symbolTable.referenceProperty(descriptor, { property }) +/* + backingField?.descriptor?.let { + symbolTable.declareField(UNDEFINED_OFFSET, + UNDEFINED_OFFSET, + irrelevantOrigin, + it, + builtIns.unitType, + { symbol -> backingField }) + } +*/ + property.backingField = backingField + backingField?.let { it.correspondingProperty = property } + + property.getter = + if (proto.hasGetter()) deserializeIrFunction(proto.getter, start, end, origin, property) else null + property.setter = + if (proto.hasSetter()) deserializeIrFunction(proto.setter, start, end, origin, property) else null + +// property.getter?.let { (it.descriptor as? WrappedSimpleFunctionDescriptor)?.bind(it) } +// property.setter?.let { (it.descriptor as? WrappedSimpleFunctionDescriptor)?.bind(it) } + + property.getter?.let { + val descriptor = it.descriptor + if (descriptor is WrappedSimpleFunctionDescriptor) descriptor.bind(it) + symbolTable.declareSimpleFunction(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irrelevantOrigin, + descriptor, { symbol -> it }) + + } + property.setter?.let { + val descriptor = it.descriptor + if (descriptor is WrappedSimpleFunctionDescriptor) descriptor.bind(it) + symbolTable.declareSimpleFunction(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irrelevantOrigin, + descriptor, { symbol -> it }) + } + + return property + } + + private fun deserializeIrTypeAlias( + proto: IrKlibProtoBuf.IrTypeAlias, + start: Int, + end: Int, + origin: IrDeclarationOrigin + ): IrDeclaration { + return IrErrorDeclarationImpl(start, end, WrappedClassDescriptor()) + } + + private val allKnownOrigins = + 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") {} + + protected fun deserializeDeclaration(proto: IrKlibProtoBuf.IrDeclaration, parent: IrDeclarationParent?): IrDeclaration { + + val start = proto.coordinates.startOffset + val end = proto.coordinates.endOffset + val origin = originIndex[proto.origin.name]!! + + val declarator = proto.declarator + + val declaration: IrDeclaration = when (declarator.declaratorCase) { + IR_ANONYMOUS_INIT + -> deserializeIrAnonymousInit(declarator.irAnonymousInit, start, end, origin) + IR_CONSTRUCTOR + -> deserializeIrConstructor(declarator.irConstructor, start, end, origin) + IR_FIELD + -> deserializeIrField(declarator.irField, start, end, origin) + IR_CLASS + -> deserializeIrClass(declarator.irClass, start, end, origin) + IR_FUNCTION + -> deserializeIrFunction(declarator.irFunction, start, end, origin) + IR_PROPERTY + -> deserializeIrProperty(declarator.irProperty, start, end, origin) + IR_TYPE_ALIAS + -> deserializeIrTypeAlias(declarator.irTypeAlias, start, end, origin) + IR_TYPE_PARAMETER + -> deserializeIrTypeParameter(declarator.irTypeParameter, start, end, origin) + IR_VARIABLE + -> deserializeIrVariable(declarator.irVariable, start, end, origin) + IR_VALUE_PARAMETER + -> deserializeIrValueParameter(declarator.irValueParameter, start, end, origin) + IR_ENUM_ENTRY + -> deserializeIrEnumEntry(declarator.irEnumEntry, start, end, origin) + DECLARATOR_NOT_SET + -> error("Declaration deserialization not implemented: ${declarator.declaratorCase}") + } + + val annotations = deserializeAnnotations(proto.annotations) + declaration.annotations.addAll(annotations) + + parent?.let { declaration.parent = it } + + val sourceFileName = proto.fileName + + val descriptor = declaration.descriptor + + if (descriptor is WrappedDeclarationDescriptor<*>) { + when (declaration) { + is IrValueParameter -> + if (descriptor is WrappedValueParameterDescriptor) descriptor.bind(declaration) + else (descriptor as WrappedReceiverParameterDescriptor).bind(declaration) + is IrVariable -> (descriptor as WrappedVariableDescriptor).bind(declaration) + is IrTypeParameter -> (descriptor as WrappedTypeParameterDescriptor).bind(declaration) + is IrAnonymousInitializer -> (descriptor as WrappedClassDescriptor).bind(parent!! as IrClass) + is IrClass -> (descriptor as WrappedClassDescriptor).bind(declaration) + is IrConstructor -> (descriptor as WrappedClassConstructorDescriptor).bind(declaration) + is IrField -> (descriptor as WrappedFieldDescriptor).bind(declaration) + is IrProperty -> (descriptor as WrappedPropertyDescriptor).bind(declaration) + is IrEnumEntry -> (descriptor as WrappedEnumEntryDescriptor).bind(declaration) + is IrSimpleFunction -> (descriptor as WrappedSimpleFunctionDescriptor).bind(declaration) + } + } + logger.log { "### Deserialized declaration: ${descriptor} -> ${ir2string(declaration)}" } + + return declaration + } +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleSerializer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleSerializer.kt new file mode 100644 index 00000000000..4071fefe5db --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrModuleSerializer.kt @@ -0,0 +1,1153 @@ +/* + * 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.LoggingContext +import org.jetbrains.kotlin.backend.common.descriptors.KnownPackageFragmentDescriptor +import org.jetbrains.kotlin.backend.common.ir.ir2string +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.ClassKind.* +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.SourceManager +import org.jetbrains.kotlin.ir.SourceRangeInfo +import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +import org.jetbrains.kotlin.ir.backend.js.utils.Namer +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl +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.js.resolve.JsPlatform.builtIns +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.types.Variance + +internal class IrModuleSerializer( + val logger: LoggingContext, + val declarationTable: DeclarationTable, + val bodiesOnlyForInlines: Boolean = false +) { + + private val loopIndex = mutableMapOf() + private var currentLoopIndex = 0 + val descriptorReferenceSerializer = DescriptorReferenceSerializer(declarationTable, { string -> serializeString(string) }) + + // 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() + + // 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 protoStringMap = mutableMapOf() + val protoStringArray = arrayListOf() + + /* ------- Common fields ---------------------------------------------------- */ + + private fun serializeIrDeclarationOrigin(origin: IrDeclarationOrigin) = + IrKlibProtoBuf.IrDeclarationOrigin.newBuilder() + .setCustom(serializeString((origin as IrDeclarationOriginImpl).name)) + .build() + + private fun serializeIrStatementOrigin(origin: IrStatementOrigin) = + IrKlibProtoBuf.IrStatementOrigin.newBuilder() + .setName(serializeString((origin as IrStatementOriginImpl).debugName)) + .build() + + private fun serializeVisibility(visibility: Visibility) = + IrKlibProtoBuf.Visibility.newBuilder() + .setName(serializeString(visibility.name)) + .build() + + private fun serializeCoordinates(start: Int, end: Int): IrKlibProtoBuf.Coordinates { + return IrKlibProtoBuf.Coordinates.newBuilder() + .setStartOffset(start) + .setEndOffset(end) + .build() + } + + /* ------- Strings ---------------------------------------------------------- */ + + fun serializeString(value: String): IrKlibProtoBuf.String { + val proto = IrKlibProtoBuf.String.newBuilder() + proto.index = protoStringMap.getOrPut(value) { + protoStringArray.add(value) + protoStringArray.size - 1 + } + return proto.build() + } + + /* ------- IrSymbols -------------------------------------------------------- */ + + fun protoSymbolKind(symbol: IrSymbol): IrKlibProtoBuf.IrSymbolKind = when (symbol) { + is IrAnonymousInitializerSymbol -> + IrKlibProtoBuf.IrSymbolKind.ANONYMOUS_INIT_SYMBOL + is IrClassSymbol -> + IrKlibProtoBuf.IrSymbolKind.CLASS_SYMBOL + is IrConstructorSymbol -> + IrKlibProtoBuf.IrSymbolKind.CONSTRUCTOR_SYMBOL + is IrTypeParameterSymbol -> + IrKlibProtoBuf.IrSymbolKind.TYPE_PARAMETER_SYMBOL + is IrEnumEntrySymbol -> + IrKlibProtoBuf.IrSymbolKind.ENUM_ENTRY_SYMBOL + is IrVariableSymbol -> + IrKlibProtoBuf.IrSymbolKind.VARIABLE_SYMBOL + is IrValueParameterSymbol -> + if (symbol.descriptor is ReceiverParameterDescriptor) // TODO: we use descriptor here. + IrKlibProtoBuf.IrSymbolKind.RECEIVER_PARAMETER_SYMBOL + else + IrKlibProtoBuf.IrSymbolKind.VALUE_PARAMETER_SYMBOL + is IrSimpleFunctionSymbol -> + IrKlibProtoBuf.IrSymbolKind.FUNCTION_SYMBOL + is IrReturnableBlockSymbol -> + IrKlibProtoBuf.IrSymbolKind.RETURNABLE_BLOCK_SYMBOL + is IrFieldSymbol -> + if (symbol.owner.correspondingProperty.let { it == null || it.isDelegated }) + IrKlibProtoBuf.IrSymbolKind.STANDALONE_FIELD_SYMBOL + else + IrKlibProtoBuf.IrSymbolKind.FIELD_SYMBOL + else -> + TODO("Unexpected symbol kind: $symbol") + } + + fun serializeIrSymbolData(symbol: IrSymbol): IrKlibProtoBuf.IrSymbolData { + + val declaration = symbol.owner as? IrDeclaration ?: error("Expected IrDeclaration: ${symbol.owner}") + + val proto = IrKlibProtoBuf.IrSymbolData.newBuilder() + proto.kind = protoSymbolKind(symbol) + + val uniqId = + declarationTable.uniqIdByDeclaration(declaration) + proto.setUniqId(protoUniqId(uniqId)) + + val topLevelUniqId = + declarationTable.uniqIdByDeclaration((declaration).findTopLevelDeclaration()) + proto.setTopLevelUniqId(protoUniqId(topLevelUniqId)) + + descriptorReferenceSerializer.serializeDescriptorReference(declaration) ?. let { + proto.setDescriptorReference(it) + } + + return proto.build() + } + + fun serializeIrSymbol(symbol: IrSymbol): IrKlibProtoBuf.IrSymbol { + val proto = IrKlibProtoBuf.IrSymbol.newBuilder() + proto.index = protoSymbolMap.getOrPut(symbol) { + protoSymbolArray.add(serializeIrSymbolData(symbol)) + protoSymbolArray.size - 1 + } + return proto.build() + } + + /* ------- IrTypes ---------------------------------------------------------- */ + + // TODO: we, probably, need a type table. + + private fun serializeTypeArguments(call: IrMemberAccessExpression): IrKlibProtoBuf.TypeArguments { + val proto = IrKlibProtoBuf.TypeArguments.newBuilder() + for (i in 0 until call.typeArgumentsCount) { + proto.addTypeArgument(serializeIrType(call.getTypeArgument(i)!!)) + } + return proto.build() + } + + fun serializeIrTypeVariance(variance: Variance) = when (variance) { + Variance.IN_VARIANCE -> IrKlibProtoBuf.IrTypeVariance.IN + Variance.OUT_VARIANCE -> IrKlibProtoBuf.IrTypeVariance.OUT + Variance.INVARIANT -> IrKlibProtoBuf.IrTypeVariance.INV + } + + fun serializeAnnotations(annotations: List): IrKlibProtoBuf.Annotations { + val proto = IrKlibProtoBuf.Annotations.newBuilder() + annotations.forEach { + proto.addAnnotation(serializeCall(it)) + } + return proto.build() + } + + fun serializeIrTypeProjection(argument: IrTypeProjection) = IrKlibProtoBuf.IrTypeProjection.newBuilder() + .setVariance(serializeIrTypeVariance(argument.variance)) + .setType(serializeIrType(argument.type)) + .build() + + fun serializeTypeArgument(argument: IrTypeArgument): IrKlibProtoBuf.IrTypeArgument { + val proto = IrKlibProtoBuf.IrTypeArgument.newBuilder() + when (argument) { + is IrStarProjection -> + proto.star = IrKlibProtoBuf.IrStarProjection.newBuilder() + .build() // TODO: Do we need a singletone here? Or just an enum? + is IrTypeProjection -> + proto.type = serializeIrTypeProjection(argument) + else -> TODO("Unexpected type argument kind: $argument") + } + return proto.build() + } + + fun serializeSimpleType(type: IrSimpleType): IrKlibProtoBuf.IrSimpleType { + val proto = IrKlibProtoBuf.IrSimpleType.newBuilder() + .setAnnotations(serializeAnnotations(type.annotations)) + .setClassifier(serializeIrSymbol(type.classifier)) + .setHasQuestionMark(type.hasQuestionMark) + type.arguments.forEach { + proto.addArgument(serializeTypeArgument(it)) + } + return proto.build() + } + + fun serializeDynamicType(type: IrDynamicType) = IrKlibProtoBuf.IrDynamicType.newBuilder() + .setAnnotations(serializeAnnotations(type.annotations)) + .build() + + fun serializeErrorType(type: IrErrorType) = IrKlibProtoBuf.IrErrorType.newBuilder() + .setAnnotations(serializeAnnotations(type.annotations)) + .build() + + private fun serializeIrTypeData(type: IrType): IrKlibProtoBuf.IrType { + logger.log { "### serializing IrType: " + type } + val proto = IrKlibProtoBuf.IrType.newBuilder() + when (type) { + is IrSimpleType -> + proto.simple = serializeSimpleType(type) + is IrDynamicType -> + proto.dynamic = serializeDynamicType(type) + is IrErrorType -> + proto.error = serializeErrorType(type) + else -> TODO("IrType serialization not implemented yet: $type.") + } + return proto.build() + } + + enum class IrTypeKind { + SIMPLE, + DYNAMIC, + ERROR + } + + enum class IrTypeArgumentKind { + STAR, + PROJECTION + } + + // This is just IrType repacked as a data class, good to address a hash map. + data class IrTypeKey ( + val kind: IrTypeKind, + val classifier: IrClassifierSymbol?, + val hasQuestionMark: Boolean?, + val arguments: List?, + val annotations: List + ) + + data class IrTypeArgumentKey ( + val kind: IrTypeArgumentKind, + val variance: Variance?, + val type: IrTypeKey? + ) + + val IrType.toIrTypeKey: IrTypeKey get() = IrTypeKey( + kind = when (this) { + is IrSimpleType -> IrTypeKind.SIMPLE + is IrDynamicType -> IrTypeKind.DYNAMIC + is IrErrorType -> IrTypeKind.ERROR + else -> error("Unexpected IrType kind: $this") + }, + classifier = this.classifierOrNull, + hasQuestionMark = (this as? IrSimpleType)?.hasQuestionMark, + arguments = (this as? IrSimpleType)?.arguments?.map { it.toIrTypeArgumentKey }, + annotations = this.annotations + ) + + val IrTypeArgument.toIrTypeArgumentKey: IrTypeArgumentKey get() = IrTypeArgumentKey( + kind = when (this) { + is IrStarProjection -> IrTypeArgumentKind.STAR + is IrTypeProjection -> IrTypeArgumentKind.PROJECTION + else -> error("Unexpected type argument kind: $this") + }, + variance = (this as? IrTypeProjection)?.variance, + type = (this as? IrTypeProjection)?.type?.toIrTypeKey + ) + + fun serializeIrType(type: IrType): IrKlibProtoBuf.IrTypeIndex { + val proto = IrKlibProtoBuf.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 ""}") + // println("new key = $key") + protoTypeArray.add(serializeIrTypeData(type)) + protoTypeArray.size - 1 + } + return proto.build() + } + + /* -------------------------------------------------------------------------- */ + + private fun serializeBlockBody(expression: IrBlockBody): IrKlibProtoBuf.IrBlockBody { + val proto = IrKlibProtoBuf.IrBlockBody.newBuilder() + expression.statements.forEach { + proto.addStatement(serializeStatement(it)) + } + return proto.build() + } + + private fun serializeBranch(branch: IrBranch): IrKlibProtoBuf.IrBranch { + val proto = IrKlibProtoBuf.IrBranch.newBuilder() + + proto.condition = serializeExpression(branch.condition) + proto.result = serializeExpression(branch.result) + + return proto.build() + } + + private fun serializeBlock(block: IrBlock): IrKlibProtoBuf.IrBlock { + val isLambdaOrigin = + block.origin == IrStatementOrigin.LAMBDA || + block.origin == IrStatementOrigin.ANONYMOUS_FUNCTION + val proto = IrKlibProtoBuf.IrBlock.newBuilder() + .setIsLambdaOrigin(isLambdaOrigin) + block.statements.forEach { + proto.addStatement(serializeStatement(it)) + } + return proto.build() + } + + private fun serializeComposite(composite: IrComposite): IrKlibProtoBuf.IrComposite { + val proto = IrKlibProtoBuf.IrComposite.newBuilder() + composite.statements.forEach { + proto.addStatement(serializeStatement(it)) + } + return proto.build() + } + + private fun serializeCatch(catch: IrCatch): IrKlibProtoBuf.IrCatch { + val proto = IrKlibProtoBuf.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() + expression.arguments.forEach { + proto.addArgument(serializeExpression(it)) + } + return proto.build() + } + + private fun irCallToPrimitiveKind(call: IrCall): IrKlibProtoBuf.IrCall.Primitive = when (call) { + is IrNullaryPrimitiveImpl + -> IrKlibProtoBuf.IrCall.Primitive.NULLARY + is IrUnaryPrimitiveImpl + -> IrKlibProtoBuf.IrCall.Primitive.UNARY + is IrBinaryPrimitiveImpl + -> IrKlibProtoBuf.IrCall.Primitive.BINARY + else + -> IrKlibProtoBuf.IrCall.Primitive.NOT_PRIMITIVE + } + + private fun serializeMemberAccessCommon(call: IrMemberAccessExpression): IrKlibProtoBuf.MemberAccessCommon { + val proto = IrKlibProtoBuf.MemberAccessCommon.newBuilder() + if (call.extensionReceiver != null) { + proto.extensionReceiver = serializeExpression(call.extensionReceiver!!) + } + + if (call.dispatchReceiver != null) { + proto.dispatchReceiver = serializeExpression(call.dispatchReceiver!!) + } + proto.typeArguments = serializeTypeArguments(call) + + for (index in 0..call.valueArgumentsCount - 1) { + val actual = call.getValueArgument(index) + val argOrNull = IrKlibProtoBuf.NullableIrExpression.newBuilder() + if (actual == null) { + // Am I observing an IR generation regression? + // I see a lack of arg for an empty vararg, + // rather than an empty vararg node. + + // TODO: how do we assert that without descriptora? + //assert(it.varargElementType != null || it.hasDefaultValue()) + } else { + argOrNull.expression = serializeExpression(actual) + } + proto.addValueArgument(argOrNull) + } + return proto.build() + } + + private fun serializeCall(call: IrCall): IrKlibProtoBuf.IrCall { + val proto = IrKlibProtoBuf.IrCall.newBuilder() + + proto.kind = irCallToPrimitiveKind(call) + proto.symbol = serializeIrSymbol(call.symbol) + + call.superQualifierSymbol?.let { + proto.`super` = serializeIrSymbol(it) + } + proto.memberAccess = serializeMemberAccessCommon(call) + return proto.build() + } + + private fun serializeFunctionReference(callable: IrFunctionReference): IrKlibProtoBuf.IrFunctionReference { + val proto = IrKlibProtoBuf.IrFunctionReference.newBuilder() + .setSymbol(serializeIrSymbol(callable.symbol)) + .setMemberAccess(serializeMemberAccessCommon(callable)) + callable.origin?.let { proto.origin = serializeIrStatementOrigin(it) } + return proto.build() + } + + + private fun serializePropertyReference(callable: IrPropertyReference): IrKlibProtoBuf.IrPropertyReference { + val proto = IrKlibProtoBuf.IrPropertyReference.newBuilder() + .setMemberAccess(serializeMemberAccessCommon(callable)) + callable.field?.let { proto.field = serializeIrSymbol(it) } + callable.getter?.let { proto.getter = serializeIrSymbol(it) } + callable.setter?.let { proto.setter = serializeIrSymbol(it) } + callable.origin?.let { proto.origin = serializeIrStatementOrigin(it) } + val property = callable.getter!!.owner.correspondingProperty!! + descriptorReferenceSerializer.serializeDescriptorReference(property)?.let { proto.setDescriptor(it) } + return proto.build() + } + + private fun serializeClassReference(expression: IrClassReference): IrKlibProtoBuf.IrClassReference { + val proto = IrKlibProtoBuf.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() + when (value.kind) { + IrConstKind.Null -> proto.`null` = true + IrConstKind.Boolean -> proto.boolean = value.value as Boolean + IrConstKind.Byte -> proto.byte = (value.value as Byte).toInt() + IrConstKind.Char -> proto.char = (value.value as Char).toInt() + IrConstKind.Short -> proto.short = (value.value as Short).toInt() + IrConstKind.Int -> proto.int = value.value as Int + IrConstKind.Long -> proto.long = value.value as Long + IrConstKind.String -> proto.string = serializeString(value.value as String) + IrConstKind.Float -> proto.float = value.value as Float + IrConstKind.Double -> proto.double = value.value as Double + } + return proto.build() + } + + private fun serializeDelegatingConstructorCall(call: IrDelegatingConstructorCall): IrKlibProtoBuf.IrDelegatingConstructorCall { + val proto = IrKlibProtoBuf.IrDelegatingConstructorCall.newBuilder() + .setSymbol(serializeIrSymbol(call.symbol)) + .setMemberAccess(serializeMemberAccessCommon(call)) + return proto.build() + } + + private fun serializeDoWhile(expression: IrDoWhileLoop): IrKlibProtoBuf.IrDoWhile { + val proto = IrKlibProtoBuf.IrDoWhile.newBuilder() + .setLoop(serializeLoop(expression)) + + return proto.build() + } + + fun serializeEnumConstructorCall(call: IrEnumConstructorCall): IrKlibProtoBuf.IrEnumConstructorCall { + val proto = IrKlibProtoBuf.IrEnumConstructorCall.newBuilder() + .setSymbol(serializeIrSymbol(call.symbol)) + .setMemberAccess(serializeMemberAccessCommon(call)) + return proto.build() + } + + private fun serializeGetClass(expression: IrGetClass): IrKlibProtoBuf.IrGetClass { + val proto = IrKlibProtoBuf.IrGetClass.newBuilder() + .setArgument(serializeExpression(expression.argument)) + return proto.build() + } + + private fun serializeGetEnumValue(expression: IrGetEnumValue): IrKlibProtoBuf.IrGetEnumValue { + val proto = IrKlibProtoBuf.IrGetEnumValue.newBuilder() + .setSymbol(serializeIrSymbol(expression.symbol)) + return proto.build() + } + + private fun serializeFieldAccessCommon(expression: IrFieldAccessExpression): IrKlibProtoBuf.FieldAccessCommon { + val proto = IrKlibProtoBuf.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() + .setFieldAccess(serializeFieldAccessCommon(expression)) + return proto.build() + } + + private fun serializeGetValue(expression: IrGetValue): IrKlibProtoBuf.IrGetValue { + val proto = IrKlibProtoBuf.IrGetValue.newBuilder() + .setSymbol(serializeIrSymbol(expression.symbol)) + return proto.build() + } + + private fun serializeGetObject(expression: IrGetObjectValue): IrKlibProtoBuf.IrGetObject { + val proto = IrKlibProtoBuf.IrGetObject.newBuilder() + .setSymbol(serializeIrSymbol(expression.symbol)) + return proto.build() + } + + private fun serializeInstanceInitializerCall(call: IrInstanceInitializerCall): IrKlibProtoBuf.IrInstanceInitializerCall { + val proto = IrKlibProtoBuf.IrInstanceInitializerCall.newBuilder() + + proto.symbol = serializeIrSymbol(call.classSymbol) + + return proto.build() + } + + private fun serializeReturn(expression: IrReturn): IrKlibProtoBuf.IrReturn { + val proto = IrKlibProtoBuf.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() + .setFieldAccess(serializeFieldAccessCommon(expression)) + .setValue(serializeExpression(expression.value)) + return proto.build() + } + + private fun serializeSetVariable(expression: IrSetVariable): IrKlibProtoBuf.IrSetVariable { + val proto = IrKlibProtoBuf.IrSetVariable.newBuilder() + .setSymbol(serializeIrSymbol(expression.symbol)) + .setValue(serializeExpression(expression.value)) + return proto.build() + } + + private fun serializeSpreadElement(element: IrSpreadElement): IrKlibProtoBuf.IrSpreadElement { + val coordinates = serializeCoordinates(element.startOffset, element.endOffset) + return IrKlibProtoBuf.IrSpreadElement.newBuilder() + .setExpression(serializeExpression(element.expression)) + .setCoordinates(coordinates) + .build() + } + + private fun serializeSyntheticBody(expression: IrSyntheticBody) = IrKlibProtoBuf.IrSyntheticBody.newBuilder() + .setKind( + when (expression.kind) { + IrSyntheticBodyKind.ENUM_VALUES -> IrKlibProtoBuf.IrSyntheticBodyKind.ENUM_VALUES + IrSyntheticBodyKind.ENUM_VALUEOF -> IrKlibProtoBuf.IrSyntheticBodyKind.ENUM_VALUEOF + } + ) + .build() + + private fun serializeThrow(expression: IrThrow): IrKlibProtoBuf.IrThrow { + val proto = IrKlibProtoBuf.IrThrow.newBuilder() + .setValue(serializeExpression(expression.value)) + return proto.build() + } + + private fun serializeTry(expression: IrTry): IrKlibProtoBuf.IrTry { + val proto = IrKlibProtoBuf.IrTry.newBuilder() + .setResult(serializeExpression(expression.tryResult)) + val catchList = expression.catches + catchList.forEach { + proto.addCatch(serializeStatement(it)) + } + val finallyExpression = expression.finallyExpression + if (finallyExpression != null) { + proto.finally = serializeExpression(finallyExpression) + } + return proto.build() + } + + private fun serializeTypeOperator(operator: IrTypeOperator): IrKlibProtoBuf.IrTypeOperator = when (operator) { + IrTypeOperator.CAST + -> IrKlibProtoBuf.IrTypeOperator.CAST + IrTypeOperator.IMPLICIT_CAST + -> IrKlibProtoBuf.IrTypeOperator.IMPLICIT_CAST + IrTypeOperator.IMPLICIT_NOTNULL + -> IrKlibProtoBuf.IrTypeOperator.IMPLICIT_NOTNULL + IrTypeOperator.IMPLICIT_COERCION_TO_UNIT + -> IrKlibProtoBuf.IrTypeOperator.IMPLICIT_COERCION_TO_UNIT + IrTypeOperator.IMPLICIT_INTEGER_COERCION + -> IrKlibProtoBuf.IrTypeOperator.IMPLICIT_INTEGER_COERCION + IrTypeOperator.SAFE_CAST + -> IrKlibProtoBuf.IrTypeOperator.SAFE_CAST + IrTypeOperator.INSTANCEOF + -> IrKlibProtoBuf.IrTypeOperator.INSTANCEOF + IrTypeOperator.NOT_INSTANCEOF + -> IrKlibProtoBuf.IrTypeOperator.NOT_INSTANCEOF + IrTypeOperator.SAM_CONVERSION + -> IrKlibProtoBuf.IrTypeOperator.SAM_CONVERSION + } + + private fun serializeTypeOp(expression: IrTypeOperatorCall): IrKlibProtoBuf.IrTypeOp { + val proto = IrKlibProtoBuf.IrTypeOp.newBuilder() + .setOperator(serializeTypeOperator(expression.operator)) + .setOperand(serializeIrType(expression.typeOperand)) + .setArgument(serializeExpression(expression.argument)) + return proto.build() + + } + + private fun serializeVararg(expression: IrVararg): IrKlibProtoBuf.IrVararg { + val proto = IrKlibProtoBuf.IrVararg.newBuilder() + .setElementType(serializeIrType(expression.varargElementType)) + expression.elements.forEach { + proto.addElement(serializeVarargElement(it)) + } + return proto.build() + } + + private fun serializeVarargElement(element: IrVarargElement): IrKlibProtoBuf.IrVarargElement { + val proto = IrKlibProtoBuf.IrVarargElement.newBuilder() + when (element) { + is IrExpression + -> proto.expression = serializeExpression(element) + is IrSpreadElement + -> proto.spreadElement = serializeSpreadElement(element) + else -> error("Unknown vararg element kind") + } + return proto.build() + } + + private fun serializeWhen(expression: IrWhen): IrKlibProtoBuf.IrWhen { + val proto = IrKlibProtoBuf.IrWhen.newBuilder() + + val branches = expression.branches + branches.forEach { + proto.addBranch(serializeStatement(it)) + } + + return proto.build() + } + + private fun serializeLoop(expression: IrLoop): IrKlibProtoBuf.Loop { + val proto = IrKlibProtoBuf.Loop.newBuilder() + .setCondition(serializeExpression(expression.condition)) + val label = expression.label?.let { serializeString(it) } + if (label != null) { + proto.label = label + } + + proto.loopId = currentLoopIndex + loopIndex[expression] = currentLoopIndex++ + + val body = expression.body + if (body != null) { + proto.body = serializeExpression(body) + } + + return proto.build() + } + + private fun serializeWhile(expression: IrWhileLoop): IrKlibProtoBuf.IrWhile { + val proto = IrKlibProtoBuf.IrWhile.newBuilder() + .setLoop(serializeLoop(expression)) + + return proto.build() + } + + private fun serializeDynamicMemberExpression(expression: IrDynamicMemberExpression): IrKlibProtoBuf.IrDynamicMemberExpression { + val proto = IrKlibProtoBuf.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() + .setOperator(serializeDynamicOperator(expression.operator)) + .setReceiver(serializeExpression(expression.receiver)) + + expression.arguments.forEach { proto.addArgument(serializeExpression(it)) } + + return proto.build() + } + + private fun serializeDynamicOperator(operator: IrDynamicOperator) = when (operator) { + IrDynamicOperator.UNARY_PLUS -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS + IrDynamicOperator.UNARY_MINUS -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_MINUS + + IrDynamicOperator.EXCL -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCL + + IrDynamicOperator.PREFIX_INCREMENT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_INCREMENT + IrDynamicOperator.PREFIX_DECREMENT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT + + IrDynamicOperator.POSTFIX_INCREMENT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT + IrDynamicOperator.POSTFIX_DECREMENT -> IrKlibProtoBuf.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.GT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.GT + IrDynamicOperator.LT -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.LT + IrDynamicOperator.GE -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.GE + IrDynamicOperator.LE -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.LE + + IrDynamicOperator.EQEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ + IrDynamicOperator.EXCLEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ + + IrDynamicOperator.EQEQEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ + IrDynamicOperator.EXCLEQEQ -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ + + IrDynamicOperator.ANDAND -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND + IrDynamicOperator.OROR -> IrKlibProtoBuf.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.ARRAY_ACCESS -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.ARRAY_ACCESS + + IrDynamicOperator.INVOKE -> IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.INVOKE + } + + private fun serializeBreak(expression: IrBreak): IrKlibProtoBuf.IrBreak { + val proto = IrKlibProtoBuf.IrBreak.newBuilder() + val label = expression.label?.let { serializeString(it) } + if (label != null) { + proto.label = label + } + val loopId = loopIndex[expression.loop]!! + proto.loopId = loopId + + return proto.build() + } + + private fun serializeContinue(expression: IrContinue): IrKlibProtoBuf.IrContinue { + val proto = IrKlibProtoBuf.IrContinue.newBuilder() + val label = expression.label?.let { serializeString(it) } + if (label != null) { + proto.label = label + } + val loopId = loopIndex[expression.loop]!! + proto.loopId = loopId + + return proto.build() + } + + private fun serializeExpression(expression: IrExpression): IrKlibProtoBuf.IrExpression { + logger.log { "### serializing Expression: ${ir2string(expression)}" } + + val coordinates = serializeCoordinates(expression.startOffset, expression.endOffset) + val proto = IrKlibProtoBuf.IrExpression.newBuilder() + .setType(serializeIrType(expression.type)) + .setCoordinates(coordinates) + + val operationProto = IrKlibProtoBuf.IrOperation.newBuilder() + + // TODO: make me a visitor. + when (expression) { + is IrBlock -> operationProto.block = serializeBlock(expression) + is IrBreak -> operationProto.`break` = serializeBreak(expression) + is IrClassReference + -> operationProto.classReference = serializeClassReference(expression) + is IrCall -> operationProto.call = serializeCall(expression) + + is IrComposite -> operationProto.composite = serializeComposite(expression) + is IrConst<*> -> operationProto.const = serializeConst(expression) + is IrContinue -> operationProto.`continue` = serializeContinue(expression) + is IrDelegatingConstructorCall + -> operationProto.delegatingConstructorCall = serializeDelegatingConstructorCall(expression) + is IrDoWhileLoop -> operationProto.doWhile = serializeDoWhile(expression) + is IrEnumConstructorCall + -> operationProto.enumConstructorCall = serializeEnumConstructorCall(expression) + is IrFunctionReference + -> operationProto.functionReference = serializeFunctionReference(expression) + is IrGetClass -> operationProto.getClass = serializeGetClass(expression) + is IrGetField -> operationProto.getField = serializeGetField(expression) + is IrGetValue -> operationProto.getValue = serializeGetValue(expression) + is IrGetEnumValue + -> operationProto.getEnumValue = serializeGetEnumValue(expression) + is IrGetObjectValue + -> operationProto.getObject = serializeGetObject(expression) + is IrInstanceInitializerCall + -> operationProto.instanceInitializerCall = serializeInstanceInitializerCall(expression) + is IrPropertyReference + -> operationProto.propertyReference = serializePropertyReference(expression) + is IrReturn -> operationProto.`return` = serializeReturn(expression) + is IrSetField -> operationProto.setField = serializeSetField(expression) + is IrSetVariable -> operationProto.setVariable = serializeSetVariable(expression) + is IrStringConcatenation + -> operationProto.stringConcat = serializeStringConcat(expression) + is IrThrow -> operationProto.`throw` = serializeThrow(expression) + is IrTry -> operationProto.`try` = serializeTry(expression) + is IrTypeOperatorCall + -> operationProto.typeOp = serializeTypeOp(expression) + is IrVararg -> operationProto.vararg = serializeVararg(expression) + is IrWhen -> operationProto.`when` = serializeWhen(expression) + is IrWhileLoop -> operationProto.`while` = serializeWhile(expression) + is IrDynamicMemberExpression -> operationProto.dynamicMember = serializeDynamicMemberExpression(expression) + is IrDynamicOperatorExpression -> operationProto.dynamicOperator = serializeDynamicOperatorExpression(expression) + else -> { + TODO("Expression serialization not implemented yet: ${ir2string(expression)}.") + } + } + proto.setOperation(operationProto) + + return proto.build() + } + + private fun serializeStatement(statement: IrElement): IrKlibProtoBuf.IrStatement { + logger.log { "### serializing Statement: ${ir2string(statement)}" } + + val coordinates = serializeCoordinates(statement.startOffset, statement.endOffset) + val proto = IrKlibProtoBuf.IrStatement.newBuilder() + .setCoordinates(coordinates) + + when (statement) { + is IrDeclaration -> { + logger.log { " ###Declaration " }; proto.declaration = serializeDeclaration(statement) + } + is IrExpression -> { + logger.log { " ###Expression " }; proto.expression = serializeExpression(statement) + } + is IrBlockBody -> { + logger.log { " ###BlockBody " }; proto.blockBody = serializeBlockBody(statement) + } + is IrBranch -> { + logger.log { " ###Branch " }; proto.branch = serializeBranch(statement) + } + is IrCatch -> { + logger.log { " ###Catch " }; proto.catch = serializeCatch(statement) + } + is IrSyntheticBody -> { + logger.log { " ###SyntheticBody " }; proto.syntheticBody = serializeSyntheticBody(statement) + } + else -> { + TODO("Statement not implemented yet: ${ir2string(statement)}") + } + } + return proto.build() + } + + private fun serializeIrTypeAlias(typeAlias: IrTypeAlias) = IrKlibProtoBuf.IrTypeAlias.newBuilder().build() + + private fun serializeIrValueParameter(parameter: IrValueParameter): IrKlibProtoBuf.IrValueParameter { + val proto = IrKlibProtoBuf.IrValueParameter.newBuilder() + .setSymbol(serializeIrSymbol(parameter.symbol)) + .setName(serializeString(parameter.name.toString())) + .setIndex(parameter.index) + .setType(serializeIrType(parameter.type)) + .setIsCrossinline(parameter.isCrossinline) + .setIsNoinline(parameter.isNoinline) + + parameter.varargElementType?.let { proto.setVarargElementType(serializeIrType(it)) } + parameter.defaultValue?.let { proto.setDefaultValue(serializeExpression(it.expression)) } + + return proto.build() + } + + private fun serializeIrTypeParameter(parameter: IrTypeParameter): IrKlibProtoBuf.IrTypeParameter { + val proto = IrKlibProtoBuf.IrTypeParameter.newBuilder() + .setSymbol(serializeIrSymbol(parameter.symbol)) + .setName(serializeString(parameter.name.toString())) + .setIndex(parameter.index) + .setVariance(serializeIrTypeVariance(parameter.variance)) + .setIsReified(parameter.isReified) + parameter.superTypes.forEach { + proto.addSuperType(serializeIrType(it)) + } + return proto.build() + } + + private fun serializeIrTypeParameterContainer(typeParameters: List): IrKlibProtoBuf.IrTypeParameterContainer { + val proto = IrKlibProtoBuf.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())) + .setVisibility(serializeVisibility(function.visibility)) + .setIsInline(function.isInline) + .setIsExternal(function.isExternal) + .setReturnType(serializeIrType(function.returnType)) + .setTypeParameters(serializeIrTypeParameterContainer(function.typeParameters)) + + function.dispatchReceiverParameter?.let { proto.setDispatchReceiver(serializeDeclaration(it)) } + function.extensionReceiverParameter?.let { proto.setExtensionReceiver(serializeDeclaration(it)) } + function.valueParameters.forEach { + //proto.addValueParameter(serializeIrValueParameter(it)) + proto.addValueParameter(serializeDeclaration(it)) + } + if (!bodiesOnlyForInlines || function.isInline) { + function.body?.let { proto.body = serializeStatement(it) } + } + return proto.build() + } + + 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 + } + + private fun serializeIrConstructor(declaration: IrConstructor): IrKlibProtoBuf.IrConstructor = + IrKlibProtoBuf.IrConstructor.newBuilder() + .setSymbol(serializeIrSymbol(declaration.symbol)) + .setBase(serializeIrFunctionBase(declaration as IrFunctionBase)) + .setIsPrimary(declaration.isPrimary) + .build() + + private fun serializeIrFunction(declaration: IrSimpleFunction): IrKlibProtoBuf.IrFunction { + val function = declaration// as IrFunctionImpl + val proto = IrKlibProtoBuf.IrFunction.newBuilder() + .setSymbol(serializeIrSymbol(function.symbol)) + .setModality(serializeModality(function.modality)) + .setIsTailrec(function.isTailrec) + .setIsSuspend(function.isSuspend) + + function.overriddenSymbols.forEach { + proto.addOverridden(serializeIrSymbol(it)) + } + + //function.correspondingProperty?.let { + // val uniqId = declarationTable.uniqIdByDeclaration(it) + // proto.setCorrespondingProperty(protoUniqId(uniqId)) + //} + + val base = serializeIrFunctionBase(function as IrFunctionBase) + proto.setBase(base) + + return proto.build() + } + + private fun serializeIrAnonymousInit(declaration: IrAnonymousInitializer) = IrKlibProtoBuf.IrAnonymousInit.newBuilder() + .setSymbol(serializeIrSymbol(declaration.symbol)) + .setBody(serializeStatement(declaration.body)) + .build() + + private fun serializeIrProperty(property: IrProperty): IrKlibProtoBuf.IrProperty { + val index = declarationTable.uniqIdByDeclaration(property) + + val proto = IrKlibProtoBuf.IrProperty.newBuilder() + .setIsDelegated(property.isDelegated) + .setName(serializeString(property.name.toString())) + .setVisibility(serializeVisibility(property.visibility)) + .setModality(serializeModality(property.modality)) + .setIsVar(property.isVar) + .setIsConst(property.isConst) + .setIsLateinit(property.isLateinit) + .setIsDelegated(property.isDelegated) + .setIsExternal(property.isExternal) + + descriptorReferenceSerializer.serializeDescriptorReference(property)?.let { proto.setDescriptor(it) } + + val backingField = property.backingField + val getter = property.getter + val setter = property.setter + if (backingField != null) + proto.backingField = serializeIrField(backingField) + if (getter != null) + proto.getter = serializeIrFunction(getter) + if (setter != null) + proto.setter = serializeIrFunction(setter) + + return proto.build() + } + + private fun serializeIrField(field: IrField): IrKlibProtoBuf.IrField { + val proto = IrKlibProtoBuf.IrField.newBuilder() + .setSymbol(serializeIrSymbol(field.symbol)) + .setName(serializeString(field.name.toString())) + .setVisibility(serializeVisibility(field.visibility)) + .setIsFinal(field.isFinal) + .setIsExternal(field.isExternal) + .setIsStatic(field.isStatic) + .setType(serializeIrType(field.type)) + val initializer = field.initializer?.expression + if (initializer != null) { + proto.initializer = serializeExpression(initializer) + } + return proto.build() + } + + private fun serializeIrVariable(variable: IrVariable): IrKlibProtoBuf.IrVariable { + val proto = IrKlibProtoBuf.IrVariable.newBuilder() + .setSymbol(serializeIrSymbol(variable.symbol)) + .setName(serializeString(variable.name.toString())) + .setType(serializeIrType(variable.type)) + .setIsConst(variable.isConst) + .setIsVar(variable.isVar) + .setIsLateinit(variable.isLateinit) + variable.initializer?.let { proto.initializer = serializeExpression(it) } + return proto.build() + } + + private fun serializeIrDeclarationContainer(declarations: List): IrKlibProtoBuf.IrDeclarationContainer { + val proto = IrKlibProtoBuf.IrDeclarationContainer.newBuilder() + declarations.forEach { + //if (it is IrDeclarationWithVisibility && it.visibility == Visibilities.INVISIBLE_FAKE) return@forEach + proto.addDeclaration(serializeDeclaration(it)) + } + return proto.build() + } + + 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 + } + + private fun serializeIrClass(clazz: IrClass): IrKlibProtoBuf.IrClass { + val proto = IrKlibProtoBuf.IrClass.newBuilder() + .setName(serializeString(clazz.name.toString())) + .setSymbol(serializeIrSymbol(clazz.symbol)) + .setKind(serializeClassKind(clazz.kind)) + .setVisibility(serializeVisibility(clazz.visibility)) + .setModality(serializeModality(clazz.modality)) + .setIsCompanion(clazz.isCompanion) + .setIsInner(clazz.isInner) + .setIsData(clazz.isData) + .setIsExternal(clazz.isExternal) + .setIsInline(clazz.isInline) + .setTypeParameters(serializeIrTypeParameterContainer(clazz.typeParameters)) + .setDeclarationContainer(serializeIrDeclarationContainer(clazz.declarations)) + clazz.superTypes.forEach { + proto.addSuperType(serializeIrType(it)) + } + clazz.thisReceiver?.let { proto.thisReceiver = serializeDeclaration(it) } + + return proto.build() + } + + private fun serializeIrEnumEntry(enumEntry: IrEnumEntry): IrKlibProtoBuf.IrEnumEntry { + val proto = IrKlibProtoBuf.IrEnumEntry.newBuilder() + .setName(serializeString(enumEntry.name.toString())) + .setSymbol(serializeIrSymbol(enumEntry.symbol)) + + enumEntry.initializerExpression?.let { + proto.initializer = serializeExpression(it) + } + enumEntry.correspondingClass?.let { + proto.correspondingClass = serializeDeclaration(it) + } + return proto.build() + } + + private fun serializeDeclaration(declaration: IrDeclaration): IrKlibProtoBuf.IrDeclaration { + logger.log { "### serializing Declaration: ${ir2string(declaration)}" } + + val declarator = IrKlibProtoBuf.IrDeclarator.newBuilder() + + when (declaration) { + is IrTypeAlias + -> declarator.irTypeAlias = serializeIrTypeAlias(declaration) + is IrAnonymousInitializer + -> declarator.irAnonymousInit = serializeIrAnonymousInit(declaration) + is IrConstructor + -> declarator.irConstructor = serializeIrConstructor(declaration) + is IrField + -> declarator.irField = serializeIrField(declaration) + is IrSimpleFunction + -> declarator.irFunction = serializeIrFunction(declaration) + is IrTypeParameter + -> declarator.irTypeParameter = serializeIrTypeParameter(declaration) + is IrVariable + -> declarator.irVariable = serializeIrVariable(declaration) + is IrValueParameter + -> declarator.irValueParameter = serializeIrValueParameter(declaration) + is IrClass + -> declarator.irClass = serializeIrClass(declaration) + is IrEnumEntry + -> declarator.irEnumEntry = serializeIrEnumEntry(declaration) + is IrProperty + -> declarator.irProperty = serializeIrProperty(declaration) + else + -> TODO("Declaration serialization not supported yet: $declaration") + } + + val coordinates = serializeCoordinates(declaration.startOffset, declaration.endOffset) + val annotations = serializeAnnotations(declaration.annotations) + val origin = serializeIrDeclarationOrigin(declaration.origin) + val proto = IrKlibProtoBuf.IrDeclaration.newBuilder() + .setCoordinates(coordinates) + .setAnnotations(annotations) + .setOrigin(origin) + + + proto.setDeclarator(declarator) + + return proto.build() + } + +// ---------- Top level ------------------------------------------------------ + + fun serializeFileEntry(entry: SourceManager.FileEntry) = IrKlibProtoBuf.FileEntry.newBuilder() + .setName(serializeString(entry.name)) + .addAllLineStartOffsets(entry.lineStartOffsets.asIterable()) + .build() + + val topLevelDeclarations = mutableMapOf() + + fun serializeIrFile(file: IrFile): IrKlibProtoBuf.IrFile { + val proto = IrKlibProtoBuf.IrFile.newBuilder() + .setFileEntry(serializeFileEntry(file.fileEntry)) + .setFqName(serializeString(file.fqName.toString())) + + file.declarations.forEach { + if (it is IrTypeAlias) return@forEach + if (it.descriptor.isExpectMember && !it.descriptor.isSerializableExpectClass) { + return@forEach + } + + val byteArray = serializeDeclaration(it).toByteArray() + val uniqId = declarationTable.uniqIdByDeclaration(it) + topLevelDeclarations.put(uniqId, byteArray) + proto.addDeclarationId(protoUniqId(uniqId)) + } + return proto.build() + } + + fun serializeModule(module: IrModuleFragment): IrKlibProtoBuf.IrModule { + val proto = IrKlibProtoBuf.IrModule.newBuilder() + .setName(serializeString(module.name.toString())) + + module.files.forEach { + proto.addFile(serializeIrFile(it)) + } + proto.symbolTable = IrKlibProtoBuf.IrSymbolTable.newBuilder() + .addAllSymbols(protoSymbolArray) + .build() + + proto.typeTable = IrKlibProtoBuf.IrTypeTable.newBuilder() + .addAllTypes(protoTypeArray) + .build() + + proto.stringTable = IrKlibProtoBuf.StringTable.newBuilder() + .addAllStrings(protoStringArray) + .build() + + return proto.build() + } + + fun serializedIrModule(module: IrModuleFragment): SerializedIr { + val moduleHeader = serializeModule(module).toByteArray() + return SerializedIr(moduleHeader, topLevelDeclarations, declarationTable.debugIndex) + } +} 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 new file mode 100644 index 00000000000..3c9bdb0a85c --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/IrSerializationUtil.kt @@ -0,0 +1,40 @@ +/* + * 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/KLibraryUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KLibraryUtils.kt new file mode 100644 index 00000000000..a8bfad0ad38 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KLibraryUtils.kt @@ -0,0 +1,12 @@ +/* + * 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 + +class SerializedIr ( + val module: ByteArray, + val declarations: Map, + val debugIndex: Map +) \ No newline at end of file diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KonanStringTable.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KonanStringTable.kt new file mode 100644 index 00000000000..d735f088b67 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/KonanStringTable.kt @@ -0,0 +1,53 @@ +/* + * 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.name.ClassId +import org.jetbrains.kotlin.serialization.StringTableImpl +import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.resolve.descriptorUtil.classId +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe +import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperClassifiers +import org.jetbrains.kotlin.resolve.descriptorUtil.module +import java.io.OutputStream + +class KonanStringTable : StringTableImpl() { + + fun getClassOrPackageFqNameIndex(descriptor: ClassOrPackageFragmentDescriptor): Int { + when (descriptor) { + is PackageFragmentDescriptor -> + return getPackageFqNameIndex(descriptor.fqName) + + is ClassDescriptor -> + return getFqNameIndex(descriptor as ClassifierDescriptorWithTypeParameters) + else -> error("Can not get fqNameIndex for $descriptor") + } + } + + override fun getLocalClassIdReplacement(descriptor: ClassifierDescriptorWithTypeParameters): ClassId? { + return if (descriptor.containingDeclaration is CallableMemberDescriptor) { + val superClassifiers = descriptor.getAllSuperClassifiers() + .mapNotNull { it as ClassifierDescriptorWithTypeParameters } + .filter { it != descriptor } + .toList() + if (superClassifiers.size == 1) { + superClassifiers[0].classId + } else { + val superClass = superClassifiers.find { !DescriptorUtils.isInterface(it) } + superClass?.classId ?: ClassId.topLevel(descriptor.module.builtIns.any.fqNameSafe) + } + } else { + super.getLocalClassIdReplacement(descriptor) + } + } + + fun serializeTo(output: OutputStream) { + val (strings, qualifiedNames) = buildProto() + strings.writeDelimitedTo(output) + qualifiedNames.writeDelimitedTo(output) + } +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/LegacyDescriptorUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/LegacyDescriptorUtils.kt new file mode 100644 index 00000000000..3874b7751f3 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/LegacyDescriptorUtils.kt @@ -0,0 +1,55 @@ +/* + * 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.atMostOne +import org.jetbrains.kotlin.backend.common.descriptors.propertyIfAccessor +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker +import org.jetbrains.kotlin.resolve.constants.StringValue +import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty + +internal val DeclarationDescriptor.isExpectMember: Boolean + get() = this is MemberDescriptor && this.isExpect + +internal val DeclarationDescriptor.isSerializableExpectClass: Boolean + get() = this is ClassDescriptor && ExpectedActualDeclarationChecker.shouldGenerateExpectClass(this) + +fun AnnotationDescriptor.getArgumentValueOrNull(name: String): T? { + val constantValue = this.allValueArguments.entries.atMostOne { + it.key.asString() == name + }?.value + return constantValue?.value as T? +} + +private val symbolNameAnnotation = FqName("kotlin.native.SymbolName") + +fun getAnnotationValue(annotation: AnnotationDescriptor): String? { + return annotation.allValueArguments.values.ifNotEmpty { + val stringValue = single() as? StringValue + stringValue?.value + } +} + +fun CallableMemberDescriptor.externalSymbolOrThrow(): String? { + this.annotations.findAnnotation(symbolNameAnnotation)?.let { + return getAnnotationValue(it)!! + } + + throw Error("external function ${this} must have @TypedIntrinsic, @SymbolName or @ObjCMethod annotation") +} + +tailrec internal fun DeclarationDescriptor.findPackage(): PackageFragmentDescriptor { + return if (this is PackageFragmentDescriptor) this + else this.containingDeclaration!!.findPackage() +} + +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 diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/SerializeDescriptorReference.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/SerializeDescriptorReference.kt new file mode 100644 index 00000000000..00a523f1db9 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/SerializeDescriptorReference.kt @@ -0,0 +1,108 @@ +/* + * 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.descriptorUtil.classId + + +class DescriptorReferenceSerializer(val declarationTable: DeclarationTable) { + + // 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? { + + val descriptor = declaration.descriptor + + if (!declaration.isExported() && !((declaration as? IrDeclarationWithVisibility)?.visibility == Visibilities.INVISIBLE_FAKE)) { + return null + } + if (declaration is IrAnonymousInitializer) return null + + if (descriptor is ParameterDescriptor || (descriptor is VariableDescriptor && descriptor !is PropertyDescriptor) || descriptor is TypeParameterDescriptor) return null + + val containingDeclaration = descriptor.containingDeclaration!! + + val (packageFqName, classFqName) = when (containingDeclaration) { + is ClassDescriptor -> { + val classId = containingDeclaration.classId ?: return null + Pair(classId.packageFqName.toString(), classId.relativeClassName.toString()) + } + is PackageFragmentDescriptor -> Pair(containingDeclaration.fqName.toString(), "") + else -> return null + } + + val isAccessor = declaration.isAccessor + val isBackingField = declaration is IrField && declaration.correspondingProperty != null + val isFakeOverride = declaration.origin == IrDeclarationOrigin.FAKE_OVERRIDE + val isDefaultConstructor = + descriptor is ClassConstructorDescriptor && containingDeclaration is ClassDescriptor && containingDeclaration.kind == ClassKind.OBJECT + val isEnumEntry = descriptor is ClassDescriptor && descriptor.kind == ClassKind.ENUM_ENTRY + val isEnumSpecial = declaration.origin == IrDeclarationOrigin.ENUM_CLASS_SPECIAL_MEMBER + + + val realDeclaration = if (isFakeOverride) { + when (declaration) { + is IrSimpleFunction -> declaration.resolveFakeOverrideMaybeAbstract() + is IrField -> declaration.resolveFakeOverrideMaybeAbstract() + is IrProperty -> declaration.resolveFakeOverrideMaybeAbstract() + else -> error("Unexpected fake override declaration") + } + } else { + declaration + } + + val discoverableDescriptorsDeclaration: IrDeclaration? = if (isAccessor) { + (realDeclaration as IrSimpleFunction).correspondingProperty!! + } else if (isBackingField) { + (realDeclaration as IrField).correspondingProperty!! + } else if (isDefaultConstructor || isEnumEntry) { + null + } else { + realDeclaration + } + + val uniqId = discoverableDescriptorsDeclaration?.let { declarationTable.uniqIdByDeclaration(it) } + uniqId?.let { declarationTable.descriptors.put(discoverableDescriptorsDeclaration.descriptor, it) } + + val proto = IrKlibProtoBuf.DescriptorReference.newBuilder() + .setPackageFqName(packageFqName) + .setClassFqName(classFqName) + .setName(descriptor.name.toString()) + + if (uniqId != null) proto.setUniqId(protoUniqId(uniqId)) + + if (isFakeOverride) { + proto.setIsFakeOverride(true) + } + + if (isBackingField) { + proto.setIsBackingField(true) + } + + if (isAccessor) { + if (declaration.isGetter) + proto.setIsGetter(true) + else if (declaration.isSetter) + proto.setIsSetter(true) + else + error("A property accessor which is neither a getter, nor a setter: $descriptor") + } else if (isDefaultConstructor) { + proto.setIsDefaultConstructor(true) + } else if (isEnumEntry) { + proto.setIsEnumEntry(true) + } else if (isEnumSpecial) { + proto.setIsEnumSpecial(true) + } + + return proto.build() + } +} + + diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/StringTableUtil.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/StringTableUtil.kt new file mode 100644 index 00000000000..95f6b4b8c0c --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/StringTableUtil.kt @@ -0,0 +1,35 @@ +/* + * 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.name.FqName +import org.jetbrains.kotlin.metadata.ProtoBuf +import org.jetbrains.kotlin.metadata.ProtoBuf.QualifiedNameTable.QualifiedName +import org.jetbrains.kotlin.metadata.deserialization.NameResolverImpl +import org.jetbrains.kotlin.serialization.deserialization.getClassId + +// TODO Come up with a better file name. + +internal fun NameResolverImpl.getDescriptorByFqNameIndex( + module: ModuleDescriptor, + nameTable: ProtoBuf.QualifiedNameTable, + fqNameIndex: Int): DeclarationDescriptor { + + if (fqNameIndex == -1) return module.getPackage(FqName.ROOT) + val packageName = this.getPackageFqName(fqNameIndex) + // TODO: Here we are using internals of NameresolverImpl. + // Consider extending NameResolver. + val proto = nameTable.getQualifiedName(fqNameIndex) + when (proto.kind!!) { + QualifiedName.Kind.CLASS, + QualifiedName.Kind.LOCAL -> + return module.findClassAcrossModuleDependencies(this.getClassId(fqNameIndex))!! + QualifiedName.Kind.PACKAGE -> + return module.getPackage(FqName(packageName)) + } +} + 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 new file mode 100644 index 00000000000..fe846b3c1e6 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqId.kt @@ -0,0 +1,57 @@ +/* + * 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. +data class UniqIdKey private constructor(val uniqId: UniqId, val moduleDescriptor: ModuleDescriptor?) { + constructor(moduleDescriptor: ModuleDescriptor?, uniqId: UniqId) + : this(uniqId, if (uniqId.isLocal) moduleDescriptor!! else null) +} + +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 new file mode 100644 index 00000000000..b8100ee3626 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/UniqSymbolName.kt @@ -0,0 +1,71 @@ +/* + * 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/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/ir.proto b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/ir.proto new file mode 100644 index 00000000000..953bdb32e37 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/ir.proto @@ -0,0 +1,606 @@ +syntax = "proto2"; +package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir; + +option java_outer_classname = "IrKlibProtoBuf"; +option optimize_for = LITE_RUNTIME; + +message DescriptorReference { + required string package_fq_name = 1; + required string class_fq_name = 2; + required string name = 3; + optional UniqId uniq_id = 4; + optional bool is_getter = 5 [default = false]; + optional bool is_setter = 6 [default = false]; + optional bool is_backing_field = 7 [default = false]; + optional bool is_fake_override = 8 [default = false]; + optional bool is_default_constructor = 9 [default = false]; + optional bool is_enum_entry = 10 [default = false]; + optional bool is_enum_special = 11 [default = false]; +} + +message UniqId { + required uint64 index = 1; + required bool isLocal = 2; +} + +message Coordinates { + required int32 start_offset = 1; + required int32 end_offset = 2; +} + +/* ------ Top Level---------------------------------------------- */ + +message IrDeclarationContainer { + repeated IrDeclaration declaration = 1; +} + +message FileEntry { // TODO: extend me. + required string name = 1; +} + +message IrFile { + repeated UniqId declaration_id = 1; + required FileEntry file_entry = 2; + // TODO: we need a better string management. See metadata serialization as an example. + required string fq_name = 3; +} + +message IrModule { + required string name = 1; + repeated IrFile file = 2; + required IrSymbolTable symbol_table = 3; + required IrTypeTable type_table = 4; +} + +/* ------ IrSymbols --------------------------------------------- */ + +enum IrSymbolKind { + FUNCTION_SYMBOL = 1; + CONSTRUCTOR_SYMBOL = 2; + ENUM_ENTRY_SYMBOL = 3; + FIELD_SYMBOL = 4; + VALUE_PARAMETER_SYMBOL = 5; + RETURNABLE_BLOCK_SYMBOL = 6; + CLASS_SYMBOL = 7; + TYPE_PARAMETER_SYMBOL = 8; + VARIABLE_SYMBOL = 9; + ANONYMOUS_INIT_SYMBOL = 10; + + STANDALONE_FIELD_SYMBOL = 11; // For fields without properties. WrappedFieldDescriptor, rather than WrappedPropertyDescriptor. + RECEIVER_PARAMETER_SYMBOL = 12; // ReceiverParameterDescriptor rather than ValueParameterDescriptor. +} + +message IrSymbolData { + required IrSymbolKind kind = 1; + required UniqId uniq_id = 2; + required UniqId top_level_uniq_id = 3; + optional string fqname = 4; + optional DescriptorReference descriptor_reference = 5; +} + +message IrSymbol { + required int32 index = 1; +} + +message IrSymbolTable { + repeated IrSymbolData symbols = 1; +} + +/* ------ IrTypes --------------------------------------------- */ + +enum IrTypeVariance { // Should we import metadata variance, or better stay separate? + IN = 0; + OUT = 1; + INV = 2; +} + +message Annotations { + repeated IrCall annotation = 1; +} + +message TypeArguments { + repeated IrTypeIndex type_argument = 1; +} + +message IrStarProjection { + optional bool void = 1; +} + +message IrTypeProjection { + required IrTypeVariance variance = 1; + required IrTypeIndex type = 2; +} + +message IrTypeArgument { + oneof kind { + IrStarProjection star = 1; + IrTypeProjection type = 2; + } +} + +message IrSimpleType { + required Annotations annotations = 1; + required IrSymbol classifier = 2; + required bool has_question_mark = 3; + repeated IrTypeArgument argument = 4; +} + +message IrDynamicType { + required Annotations annotations = 1; +} + +message IrErrorType { + required Annotations annotations = 1; +} + +message IrType { + oneof kind { + IrSimpleType simple = 1; + IrDynamicType dynamic = 2; + IrErrorType error = 3; + } +} + +message IrTypeTable { + repeated IrType types = 1; +} + +message IrTypeIndex { + required int32 index = 1; +} + +/* ------ IrExpressions --------------------------------------------- */ + +message IrBreak { + required int32 loop_id = 1; + optional string label = 2; +} + +message IrBlock { + required bool is_lambda_origin = 1; + repeated IrStatement statement = 2; +} + +message MemberAccessCommon { + optional IrExpression dispatch_receiver = 1; + optional IrExpression extension_receiver = 2; + repeated NullableIrExpression value_argument = 3; + required TypeArguments type_arguments = 4; +} + +message IrCall { + enum Primitive { + NOT_PRIMITIVE = 1; + NULLARY = 2; + UNARY = 3; + BINARY = 4; + } + required Primitive kind = 1; + required IrSymbol symbol = 2; + required MemberAccessCommon member_access = 3; + optional IrSymbol super = 4; +} + +message IrFunctionReference { + required IrSymbol symbol = 1; + optional string origin = 2; + required MemberAccessCommon member_access = 3; +} + + +message IrPropertyReference { + optional IrSymbol field = 1; + optional IrSymbol getter = 2; + optional IrSymbol setter = 3; + optional string origin = 4; + required MemberAccessCommon member_access = 5; +} + +message IrComposite { + repeated IrStatement statement = 1; +} + +message IrClassReference { + required IrSymbol class_symbol = 1; + required IrTypeIndex class_type = 2; +} + +message IrConst { + oneof value { + bool null = 1; + bool boolean = 2; + int32 char = 3; + int32 byte = 4; + int32 short = 5; + int32 int = 6; + int64 long = 7; + float float = 8; + double double = 9; + string string = 10; + } +} + +message IrContinue { + required int32 loop_id = 1; + optional string label = 2; +} + +message IrDelegatingConstructorCall { + required IrSymbol symbol = 1; + required MemberAccessCommon member_access = 2; +} + +message IrDoWhile { + required Loop loop = 1; +} + +message IrEnumConstructorCall { + required IrSymbol symbol = 1; + required MemberAccessCommon member_access = 2; +} + +message IrGetClass { + required IrExpression argument = 1; +} + +message IrGetEnumValue { + required IrSymbol symbol = 2; +} + +message FieldAccessCommon { + required IrSymbol symbol = 1; + optional IrSymbol super = 2; + optional IrExpression receiver = 3; +} + +message IrGetField { + required FieldAccessCommon field_access = 1; +} + +message IrGetValue { + required IrSymbol symbol = 1; +} + +message IrGetObject { + required IrSymbol symbol = 1; +} + +message IrInstanceInitializerCall { + required IrSymbol symbol = 1; +} + +message Loop { + required int32 loop_id = 1; + required IrExpression condition = 2; + optional string label = 3; + optional IrExpression body = 4; +} + +message IrReturn { + required IrSymbol return_target = 1; + required IrExpression value = 2; +} + +message IrSetField { + required FieldAccessCommon field_access = 1; + required IrExpression value = 2; +} + +message IrSetVariable { + required IrSymbol symbol = 1; + required IrExpression value = 2; +} + +message IrSpreadElement { + required IrExpression expression = 1; + required Coordinates coordinates = 2; +} + +message IrStringConcat { + repeated IrExpression argument = 1; +} + +message IrThrow { + required IrExpression value = 1; +} + +message IrTry { + required IrExpression result = 1; + repeated IrStatement catch = 2; + optional IrExpression finally = 3; +} + +message IrTypeOp { + required IrTypeOperator operator = 1; + required IrTypeIndex operand = 2; + required IrExpression argument = 3; +} + +message IrVararg { + required IrTypeIndex element_type = 1; + repeated IrVarargElement element = 2; +} + +message IrVarargElement { + oneof vararg_element { + IrExpression expression = 1; + IrSpreadElement spread_element = 2; + } +} + +message IrWhen { + repeated IrStatement branch = 1; +} + +message IrWhile { + required Loop loop = 1; +} + +// TODO: we need an extension mechanism to accomodate new +// IR operators in upcoming releases. +message IrOperation { + oneof operation { + IrBlock block = 1; + IrBreak break = 2; + IrCall call = 3; + IrClassReference class_reference = 4; + IrComposite composite = 5; + IrConst const = 6; + IrContinue continue = 7; + IrDelegatingConstructorCall delegating_constructor_call = 8; + IrDoWhile do_while = 9; + IrEnumConstructorCall enum_constructor_call = 10; + IrFunctionReference function_reference = 11; + IrGetClass get_class = 12; + IrGetEnumValue get_enum_value = 13; + IrGetField get_field = 14; + IrGetObject get_object = 15; + IrGetValue get_value = 16; + IrInstanceInitializerCall instance_initializer_call = 17; + IrPropertyReference property_reference = 18; + IrReturn return = 19; + IrSetField set_field = 20; + IrSetVariable set_variable = 21; + IrStringConcat string_concat = 22; + IrThrow throw = 23; + IrTry try = 24; + IrTypeOp type_op = 25; + IrVararg vararg = 26; + IrWhen when = 27; + IrWhile while = 28; + } +} + +enum IrTypeOperator { + CAST = 1; + IMPLICIT_CAST = 2; + IMPLICIT_NOTNULL = 3; + IMPLICIT_COERCION_TO_UNIT = 4; + IMPLICIT_INTEGER_COERCION = 5; + SAFE_CAST = 6; + INSTANCEOF = 7; + NOT_INSTANCEOF = 8; + SAM_CONVERSION = 9; +} + + +message IrExpression { + required IrOperation operation = 1; + required IrTypeIndex type = 2; + required Coordinates coordinates = 3; +} + +message NullableIrExpression { + optional IrExpression expression = 1; +} + +/* ------ Declarations --------------------------------------------- */ + +message IrTypeAlias { + // Nothing for now. +} + +message IrFunction { + required IrSymbol symbol = 1; + required IrFunctionBase base = 2; + required ModalityKind modality = 3; + required bool is_tailrec = 4; + required bool is_suspend = 5; + repeated IrSymbol overridden = 6; + //optional UniqId corresponding_property = 7; +} + +message IrFunctionBase { + required string name = 1; + required string visibility = 2; + required bool is_inline = 3; + required bool is_external = 4; + required IrTypeParameterContainer type_parameters = 5; + optional IrDeclaration dispatch_receiver = 6; + optional IrDeclaration extension_receiver = 7; + repeated IrDeclaration value_parameter = 8; + optional IrStatement body = 9; + required IrTypeIndex return_type = 10; +} + +message IrConstructor { + required IrSymbol symbol = 1; + required IrFunctionBase base = 2; + required bool is_primary = 3; + +} + +message IrField { + required IrSymbol symbol = 1; + optional IrExpression initializer = 2; + required string name = 3; + required string visibility = 4; + required bool is_final = 5; + required bool is_external = 6; + required bool is_static = 7; + required IrTypeIndex type = 8; +} + +message IrProperty { + optional DescriptorReference descriptor = 1; // IrProperty doesn't have a symbol at all. Preserve this rudiment for now. + required string name = 2; + required string visibility = 3; + required ModalityKind modality = 4; + required bool is_var = 5; + required bool is_const = 6; + required bool is_lateinit = 7; + required bool is_delegated = 8; + required bool is_external = 9; + optional IrField backing_field = 10; + optional IrFunction getter = 11; + optional IrFunction setter = 12; +} + +message IrVariable { + required string name = 1; + required IrSymbol symbol = 2; + required IrTypeIndex type = 3; + required bool is_var = 4; + required bool is_const = 5; + required bool is_lateinit = 6; + optional IrExpression initializer = 7; +} + +enum ClassKind { + CLASS = 1; + INTERFACE = 2; + ENUM_CLASS = 3; + ENUM_ENTRY = 4; + ANNOTATION_CLASS = 5; + OBJECT = 6; +} + +enum ModalityKind { // It is ModalityKind to not clash with Modality in descriptor metadata. + FINAL_MODALITY = 1; + SEALED_MODALITY = 2; + OPEN_MODALITY = 3; + ABSTRACT_MODALITY = 4; +} + +message IrValueParameter { + required IrSymbol symbol = 1; + required string name = 2; + required int32 index = 3; + required IrTypeIndex type = 4; + optional IrTypeIndex vararg_element_type = 5; + required bool is_crossinline = 6; + required bool is_noinline = 7; + optional IrExpression default_value = 8; +} + +message IrTypeParameter { + required IrSymbol symbol = 1; + required string name = 2; + required int32 index = 3; + required IrTypeVariance variance = 4; + repeated IrTypeIndex super_type = 5; + required bool is_reified = 6; +} + +message IrTypeParameterContainer { + repeated IrDeclaration type_parameter = 1; +} + +message IrClass { + required IrSymbol symbol = 1; + required string name = 2; + required ClassKind kind = 3; + required string visibility = 4; + required ModalityKind modality = 5; + // TODO: consider using flags for the booleans. + required bool is_companion = 6; + required bool is_inner = 7; + required bool is_data = 8; + required bool is_external = 9; + required bool is_inline = 10; + optional IrDeclaration this_receiver = 11; + required IrTypeParameterContainer type_parameters = 12; + required IrDeclarationContainer declaration_container = 13; + repeated IrTypeIndex super_type = 14; +} + +message IrEnumEntry { + required IrSymbol symbol = 1; + optional IrExpression initializer = 2; + optional IrDeclaration corresponding_class = 3; + required string name = 4; +} + +message IrAnonymousInit { + required IrSymbol symbol = 1; + required IrStatement body = 2; +} + +// TODO: we need an extension mechanism to accomodate new +// IR operators in upcoming releases. +message IrDeclarator { + oneof declarator { + IrAnonymousInit ir_anonymous_init = 1; + IrClass ir_class = 2; + IrConstructor ir_constructor = 3; + IrEnumEntry ir_enum_entry = 4; + IrField ir_field = 5; + IrFunction ir_function = 6; + IrProperty ir_property = 7; + IrTypeAlias ir_type_alias = 8; + IrTypeParameter ir_type_parameter = 9; + IrVariable ir_variable = 10; + IrValueParameter ir_value_parameter = 11; + } +} + +message IrDeclarationOrigin { + required string name = 1; +} + +message IrDeclaration { + required IrDeclarationOrigin origin = 1; + required Coordinates coordinates = 2; + required Annotations annotations = 3; + required IrDeclarator declarator = 4; + //repeated IrDeclaration nested = 5; + required string file_name = 5; // TODO: files should be communicated some other way, I suppose. +} + +/* ------- IrStatements --------------------------------------------- */ + +message IrBranch { + required IrExpression condition = 1; + required IrExpression result = 2; +} + +message IrBlockBody { + repeated IrStatement statement = 1; +} + +message IrCatch { + required IrDeclaration catch_parameter = 1; + required IrExpression result = 2; +} + +enum IrSyntheticBodyKind { + ENUM_VALUES = 1; + ENUM_VALUEOF = 2; +} + +message IrSyntheticBody { + required IrSyntheticBodyKind kind = 1; +} + +// Let's try to map IrElement as well as IrStatement to IrStatement. +message IrStatement { + required Coordinates coordinates = 1; + oneof statement { + IrDeclaration declaration = 2; + IrExpression expression = 3; + IrBlockBody block_body = 4; + IrBranch branch = 5; + IrCatch catch = 6; + IrSyntheticBody synthetic_body = 7; + } +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/metadata/JsKlibMetadataFragmentProvider.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/metadata/JsKlibMetadataFragmentProvider.kt index 0ce7a1208e4..d8107df6aac 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/metadata/JsKlibMetadataFragmentProvider.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/metadata/JsKlibMetadataFragmentProvider.kt @@ -64,7 +64,7 @@ fun createJsKlibMetadataPackageFragmentProvider( emptyList(), notFoundClasses, ContractDeserializerImpl(configuration, storageManager), - platformDependentDeclarationFilter = PlatformDependentDeclarationFilter.NoPlatformDependent, + platformDependentDeclarationFilter = PlatformDependentDeclarationFilter.All, extensionRegistryLite = JsKlibMetadataSerializerProtocol.extensionRegistry ) diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt index 913f17b4e0b..ff5c36562fa 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.ir.backend.js.transformers.irToJs +import org.jetbrains.kotlin.backend.common.ir.isElseBranch import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext import org.jetbrains.kotlin.ir.backend.js.lower.coroutines.COROUTINE_SWITCH import org.jetbrains.kotlin.ir.backend.js.utils.JsGenerationContext @@ -99,7 +100,7 @@ class IrElementToJsStatementTransformer : BaseIrElementToJsNodeTransformer { val functions = irClass.declarations.filterIsInstance() - val messageGetter = functions.single { it.name == Name.special("") } - val causeGetter = functions.single { it.name == Name.special("") } + + // TODO: Fix `Name.special` deserialization + val messageGetter = functions.single { it.name.asString() == "" } + val causeGetter = functions.single { it.name.asString() == "" } val msgProperty = defineProperty(classPrototypeRef, "message", getter = buildGetterFunction(messageGetter)) diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt index d0203c1649d..f798c06638e 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.ir.backend.js.transformers.irToJs import org.jetbrains.kotlin.backend.common.descriptors.isSuspend +import org.jetbrains.kotlin.backend.common.ir.isElseBranch import org.jetbrains.kotlin.ir.backend.js.utils.JsGenerationContext import org.jetbrains.kotlin.ir.backend.js.utils.Namer import org.jetbrains.kotlin.ir.declarations.IrFunction @@ -24,7 +25,7 @@ fun IrWhen.toJsNode( ): T? = branches.foldRight(null) { br, n -> val body = br.result.accept(tr, data) - if (br is IrElseBranch) body + if (isElseBranch(br)) body else { val condition = br.condition.accept(IrElementToJsExpressionTransformer(), data) node(condition, body, n) diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/Namer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/Namer.kt index ce663715aa5..bbe7ee407e6 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/Namer.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/Namer.kt @@ -99,4 +99,6 @@ object Namer { val THIS_SPECIAL_NAME = "" val SET_SPECIAL_NAME = "" + + val DYNAMIC_FILE_NAME = "" } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt index eba78eec437..95ccace5a4d 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt @@ -64,6 +64,7 @@ abstract class IrLazyDeclarationBase( } is ClassDescriptor -> stubGenerator.generateClassStub(containingDeclaration) is FunctionDescriptor -> stubGenerator.generateFunctionStub(containingDeclaration) + is PropertyDescriptor -> stubGenerator.generateFunctionStub(containingDeclaration.run { getter ?: setter!! }) else -> throw AssertionError("Package or class expected: $containingDeclaration; for $currentDescriptor") } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt index b71a31707d6..29d4f688328 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt @@ -15,6 +15,12 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl import org.jetbrains.kotlin.ir.symbols.impl.IrExternalPackageFragmentSymbolImpl +import org.jetbrains.kotlin.ir.types.IrSimpleType +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl +import org.jetbrains.kotlin.ir.types.IrSimpleType +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl import org.jetbrains.kotlin.ir.types.withHasQuestionMark import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator import org.jetbrains.kotlin.ir.util.SymbolTable @@ -72,68 +78,97 @@ class IrBuiltIns( private fun List.defineComparisonOperatorForEachType(name: String) = associate { it to defineComparisonOperator(name, it) } + private class IrTypeMapper(val type: () -> IrType, val nType: () -> IrType) + + private fun buildNullableType(irType: IrType) = with(irType as IrSimpleType) { + IrSimpleTypeImpl(classifier, true, arguments, annotations) + } + + private val primitiveTypesLazyMapping = mapOf( + builtIns.any to IrTypeMapper({ anyType }, { anyNType }), + builtIns.boolean to IrTypeMapper({ booleanType }, { buildNullableType(booleanType) }), + builtIns.char to IrTypeMapper({ charType }, { buildNullableType(charType) }), + builtIns.number to IrTypeMapper({ numberType }, { buildNullableType(numberType) }), + builtIns.byte to IrTypeMapper({ byteType }, { buildNullableType(byteType) }), + builtIns.short to IrTypeMapper({ shortType }, { buildNullableType(shortType) }), + builtIns.int to IrTypeMapper({ intType }, { buildNullableType(intType) }), + builtIns.long to IrTypeMapper({ longType }, { buildNullableType(longType) }), + builtIns.float to IrTypeMapper({ floatType }, { buildNullableType(floatType) }), + builtIns.double to IrTypeMapper({ doubleType }, { buildNullableType(doubleType) }), + builtIns.nothing to IrTypeMapper({ nothingType }, { nothingNType }), + builtIns.unit to IrTypeMapper({ unitType }, { buildNullableType(unitType) }), + builtIns.string to IrTypeMapper({ stringType }, { buildNullableType(stringType) }), + builtIns.throwable to IrTypeMapper({ throwableType }, { buildNullableType(throwableType) }) +// builtIns.array to { arrayClass.owner.defaultType } + ) + + fun getPrimitiveTypeOrNullByDescriptor(descriptor: ClassifierDescriptor, isNullable: Boolean) = + primitiveTypesLazyMapping[descriptor]?.let { + if (isNullable) it.nType() else it.type() + } as IrSimpleType? + val any = builtIns.anyType val anyN = builtIns.nullableAnyType - val anyType = any.toIrType() - val anyClass = builtIns.any.toIrSymbol() - val anyNType = anyType.withHasQuestionMark(true) + val anyType by lazy { any.toIrType() } + val anyClass by lazy { builtIns.any.toIrSymbol() } + val anyNType by lazy { anyType.withHasQuestionMark(true) } val bool = builtIns.booleanType - val booleanType = bool.toIrType() - val booleanClass = builtIns.boolean.toIrSymbol() + val booleanType by lazy { bool.toIrType() } + val booleanClass by lazy { builtIns.boolean.toIrSymbol() } val char = builtIns.charType - val charType = char.toIrType() - val charClass = builtIns.char.toIrSymbol() + val charType by lazy { char.toIrType() } + val charClass by lazy { builtIns.char.toIrSymbol() } val number = builtIns.number.defaultType - val numberType = number.toIrType() - val numberClass = builtIns.number.toIrSymbol() + val numberType by lazy { number.toIrType() } + val numberClass by lazy { builtIns.number.toIrSymbol() } val byte = builtIns.byteType - val byteType = byte.toIrType() - val byteClass = builtIns.byte.toIrSymbol() + val byteType by lazy { byte.toIrType() } + val byteClass by lazy { builtIns.byte.toIrSymbol() } val short = builtIns.shortType - val shortType = short.toIrType() - val shortClass = builtIns.short.toIrSymbol() + val shortType by lazy { short.toIrType() } + val shortClass by lazy { builtIns.short.toIrSymbol() } val int = builtIns.intType - val intType = int.toIrType() - val intClass = builtIns.int.toIrSymbol() + val intType by lazy { int.toIrType() } + val intClass by lazy { builtIns.int.toIrSymbol() } val long = builtIns.longType - val longType = long.toIrType() - val longClass = builtIns.long.toIrSymbol() + val longType by lazy { long.toIrType() } + val longClass by lazy { builtIns.long.toIrSymbol() } val float = builtIns.floatType - val floatType = float.toIrType() - val floatClass = builtIns.float.toIrSymbol() + val floatType by lazy { float.toIrType() } + val floatClass by lazy { builtIns.float.toIrSymbol() } val double = builtIns.doubleType - val doubleType = double.toIrType() - val doubleClass = builtIns.double.toIrSymbol() + val doubleType by lazy { double.toIrType() } + val doubleClass by lazy { builtIns.double.toIrSymbol() } val nothing = builtIns.nothingType val nothingN = builtIns.nullableNothingType - val nothingType = nothing.toIrType() - val nothingClass = builtIns.nothing.toIrSymbol() - val nothingNType = nothingType.withHasQuestionMark(true) + val nothingType by lazy { nothing.toIrType() } + val nothingClass by lazy { builtIns.nothing.toIrSymbol() } + val nothingNType by lazy { nothingType.withHasQuestionMark(true) } val unit = builtIns.unitType - val unitType = unit.toIrType() - val unitClass = builtIns.unit.toIrSymbol() + val unitType by lazy { unit.toIrType() } + val unitClass by lazy { builtIns.unit.toIrSymbol() } val string = builtIns.stringType - val stringType = string.toIrType() - val stringClass = builtIns.string.toIrSymbol() + val stringType by lazy { string.toIrType() } + val stringClass by lazy { builtIns.string.toIrSymbol() } - val collectionClass = builtIns.collection.toIrSymbol() + val collectionClass by lazy { builtIns.collection.toIrSymbol() } - val arrayClass = builtIns.array.toIrSymbol() + val arrayClass by lazy { builtIns.array.toIrSymbol() } - val throwableType = builtIns.throwable.defaultType.toIrType() - val throwableClass = builtIns.throwable.toIrSymbol() + val throwableType by lazy { builtIns.throwable.defaultType.toIrType() } + val throwableClass by lazy { builtIns.throwable.toIrSymbol() } val kCallableClass = builtIns.getBuiltInClassByFqName(KotlinBuiltIns.FQ_NAMES.kCallable.toSafe()).toIrSymbol() val kPropertyClass = builtIns.getBuiltInClassByFqName(KotlinBuiltIns.FQ_NAMES.kPropertyFqName.toSafe()).toIrSymbol() diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypes.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypes.kt index 2abaeb431a0..8fdf0c5c69a 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypes.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypes.kt @@ -5,9 +5,11 @@ package org.jetbrains.kotlin.ir.types +import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassifierDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor +import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.declarations.IrTypeParameter import org.jetbrains.kotlin.ir.symbols.IrClassSymbol @@ -68,6 +70,8 @@ fun IrType.makeNullable(addKotlinType:Boolean = true) = else this +var irTypeKotlinBuiltIns: KotlinBuiltIns? = null + fun IrType.toKotlinType(): KotlinType { originalKotlinType?.let { return it @@ -75,6 +79,7 @@ fun IrType.toKotlinType(): KotlinType { return when (this) { is IrSimpleType -> makeKotlinType(classifier, arguments, hasQuestionMark) + is IrDynamicType -> createDynamicType(irTypeKotlinBuiltIns!!) else -> TODO(toString()) } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt index 42ea475c2a4..2597270415c 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt @@ -21,16 +21,21 @@ import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrFieldImpl +import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl import org.jetbrains.kotlin.ir.declarations.impl.IrPropertyImpl import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl import org.jetbrains.kotlin.ir.declarations.lazy.* import org.jetbrains.kotlin.ir.expressions.impl.IrErrorExpressionImpl import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl +import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl +import org.jetbrains.kotlin.ir.types.impl.IrDynamicTypeImpl import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.hasBackingField import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.Variance +import org.jetbrains.kotlin.types.isDynamic class DeclarationStubGenerator( moduleDescriptor: ModuleDescriptor, diff --git a/generators/tests/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBuf.kt b/generators/tests/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBuf.kt index 26970735068..54d06ca0f40 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBuf.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBuf.kt @@ -58,7 +58,8 @@ 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/org/jetbrains/kotlin/ir/backend/js/lower/serialization/metadata/js.proto") +// ProtoPath("compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/metadata/js.proto"), + ProtoPath("compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/ir.proto") ) private val EXT_OPTIONS_PROTO_PATH = ProtoPath("core/metadata/src/ext_options.proto") diff --git a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateIrRuntime.kt b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateIrRuntime.kt index 81691501a64..1805cc69a6a 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateIrRuntime.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateIrRuntime.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.ir.backend.js.compile import org.jetbrains.kotlin.js.test.JsIrTestRuntime import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.KotlinTestUtils import java.io.File fun buildConfiguration(environment: KotlinCoreEnvironment): CompilerConfiguration { @@ -38,6 +39,8 @@ fun buildConfiguration(environment: KotlinCoreEnvironment): CompilerConfiguratio private val stdKlibFile = File("js/js.translator/testData/out/klibs/stdlib.klib") +private val resultJs = "js/js.translator/testData/out/klibs/result.js" + fun main() { val environment = KotlinCoreEnvironment.createForTests(Disposable { }, CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES) @@ -53,7 +56,7 @@ fun main() { val result = compile( environment.project, - JsIrTestRuntime.FULL.sources.map(::createPsiFile), + (JsIrTestRuntime.FULL.sources).map(::createPsiFile), buildConfiguration(environment), null, true, @@ -61,5 +64,7 @@ fun main() { emptyList() ) - TODO("Write library into $stdKlibFile") + File(resultJs).writeText(result.generatedCode) + +// TODO("Write library into $stdKlibFile") } \ No newline at end of file