From 2334ea2742314ca6f0306ec5c3cd31935dea6d63 Mon Sep 17 00:00:00 2001 From: Roman Artemev Date: Thu, 14 Feb 2019 18:01:09 +0300 Subject: [PATCH] [JS IR BE] Support IrDynamicExpression in proto and deserializer --- .../serialization/ir/IrKlibProtoBuf.java | 1826 +++++++++++++++++ .../serialization/ir/IrModuleDeserializer.kt | 57 + .../serialization/ir/IrModuleSerializer.kt | 64 + .../js/lower/serialization/ir/ir.proto | 50 + 4 files changed, 1997 insertions(+) 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 index 9eb5c0636c9..3be9f54c56e 100644 --- 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 @@ -34511,6 +34511,1570 @@ public final class IrKlibProtoBuf { // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrWhile) } + public interface IrDynamicMemberExpressionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + boolean hasMemberName(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String getMemberName(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + boolean hasReceiver(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getReceiver(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression} + */ + public static final class IrDynamicMemberExpression extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression) + IrDynamicMemberExpressionOrBuilder { + // Use IrDynamicMemberExpression.newBuilder() to construct. + private IrDynamicMemberExpression(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDynamicMemberExpression(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDynamicMemberExpression defaultInstance; + public static IrDynamicMemberExpression getDefaultInstance() { + return defaultInstance; + } + + public IrDynamicMemberExpression getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDynamicMemberExpression( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput = + org.jetbrains.kotlin.protobuf.ByteString.newOutput(); + org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput = + org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance( + unknownFieldsOutput, 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.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = memberName_.toBuilder(); + } + memberName_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(memberName_); + memberName_ = 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 = 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_ |= 0x00000002; + break; + } + } + } + } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + try { + unknownFieldsCodedOutput.flush(); + } catch (java.io.IOException e) { + // Should not happen + } finally { + unknownFields = unknownFieldsOutput.toByteString(); + } + makeExtensionsImmutable(); + } + } + public static org.jetbrains.kotlin.protobuf.Parser PARSER = + new org.jetbrains.kotlin.protobuf.AbstractParser() { + public IrDynamicMemberExpression parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDynamicMemberExpression(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + public static final int MEMBERNAME_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String memberName_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + public boolean hasMemberName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String getMemberName() { + return memberName_; + } + + public static final int RECEIVER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression receiver_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getReceiver() { + return receiver_; + } + + private void initFields() { + memberName_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String.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 (!hasMemberName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasReceiver()) { + memoizedIsInitialized = 0; + return false; + } + if (!getMemberName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getReceiver().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(1, memberName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, receiver_); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(1, memberName_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, receiver_); + } + size += unknownFields.size(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression 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.IrDynamicMemberExpression parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression 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.IrDynamicMemberExpression parseFrom( + byte[] data, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression 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.IrDynamicMemberExpression parseFrom( + java.io.InputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression 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.IrDynamicMemberExpression parseDelimitedFrom( + java.io.InputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression 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.IrDynamicMemberExpression parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpressionOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + memberName_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + receiver_ = 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.IrDynamicMemberExpression getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.memberName_ = memberName_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.receiver_ = receiver_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.getDefaultInstance()) return this; + if (other.hasMemberName()) { + mergeMemberName(other.getMemberName()); + } + if (other.hasReceiver()) { + mergeReceiver(other.getReceiver()); + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasMemberName()) { + + return false; + } + if (!hasReceiver()) { + + return false; + } + if (!getMemberName().isInitialized()) { + + return false; + } + if (!getReceiver().isInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression 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.IrDynamicMemberExpression) 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.String memberName_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + public boolean hasMemberName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String getMemberName() { + return memberName_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + public Builder setMemberName(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String value) { + if (value == null) { + throw new NullPointerException(); + } + memberName_ = value; + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + public Builder setMemberName( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String.Builder builderForValue) { + memberName_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + public Builder mergeMemberName(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + memberName_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String.getDefaultInstance()) { + memberName_ = + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String.newBuilder(memberName_).mergeFrom(value).buildPartial(); + } else { + memberName_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.String memberName = 1; + */ + public Builder clearMemberName() { + memberName_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.String.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + 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(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getReceiver() { + return receiver_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public Builder setReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + receiver_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public Builder setReceiver( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + receiver_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public Builder mergeReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + 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_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public Builder clearReceiver() { + receiver_ = 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.IrDynamicMemberExpression) + } + + static { + defaultInstance = new IrDynamicMemberExpression(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression) + } + + public interface IrDynamicOperatorExpressionOrBuilder extends + // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression) + org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + boolean hasOperator(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator getOperator(); + + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + boolean hasReceiver(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getReceiver(); + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + java.util.List + getArgumentList(); + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + 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 = 3; + */ + int getArgumentCount(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression} + */ + public static final class IrDynamicOperatorExpression extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements + // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression) + IrDynamicOperatorExpressionOrBuilder { + // Use IrDynamicOperatorExpression.newBuilder() to construct. + private IrDynamicOperatorExpression(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private IrDynamicOperatorExpression(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;} + + private static final IrDynamicOperatorExpression defaultInstance; + public static IrDynamicOperatorExpression getDefaultInstance() { + return defaultInstance; + } + + public IrDynamicOperatorExpression getDefaultInstanceForType() { + return defaultInstance; + } + + private final org.jetbrains.kotlin.protobuf.ByteString unknownFields; + private IrDynamicOperatorExpression( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput = + org.jetbrains.kotlin.protobuf.ByteString.newOutput(); + org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput = + org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance( + unknownFieldsOutput, 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.IrDynamicOperatorExpression.IrDynamicOperator value = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.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.IrExpression.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + 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_ |= 0x00000002; + break; + } + case 26: { + if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + argument_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + 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_ & 0x00000004) == 0x00000004)) { + argument_ = java.util.Collections.unmodifiableList(argument_); + } + try { + unknownFieldsCodedOutput.flush(); + } catch (java.io.IOException e) { + // Should not happen + } finally { + unknownFields = unknownFieldsOutput.toByteString(); + } + makeExtensionsImmutable(); + } + } + public static org.jetbrains.kotlin.protobuf.Parser PARSER = + new org.jetbrains.kotlin.protobuf.AbstractParser() { + public IrDynamicOperatorExpression parsePartialFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return new IrDynamicOperatorExpression(input, extensionRegistry); + } + }; + + @java.lang.Override + public org.jetbrains.kotlin.protobuf.Parser getParserForType() { + return PARSER; + } + + /** + * Protobuf enum {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator} + */ + public enum IrDynamicOperator + implements org.jetbrains.kotlin.protobuf.Internal.EnumLite { + /** + * UNARY_PLUS = 1; + */ + UNARY_PLUS(0, 1), + /** + * UNARY_MINUS = 2; + */ + UNARY_MINUS(1, 2), + /** + * EXCL = 3; + */ + EXCL(2, 3), + /** + * PREFIX_INCREMENT = 4; + */ + PREFIX_INCREMENT(3, 4), + /** + * POSTFIX_INCREMENT = 5; + */ + POSTFIX_INCREMENT(4, 5), + /** + * PREFIX_DECREMENT = 6; + */ + PREFIX_DECREMENT(5, 6), + /** + * POSTFIX_DECREMENT = 7; + */ + POSTFIX_DECREMENT(6, 7), + /** + * BINARY_PLUS = 8; + */ + BINARY_PLUS(7, 8), + /** + * BINARY_MINUS = 9; + */ + BINARY_MINUS(8, 9), + /** + * MUL = 10; + */ + MUL(9, 10), + /** + * DIV = 11; + */ + DIV(10, 11), + /** + * MOD = 12; + */ + MOD(11, 12), + /** + * GT = 13; + */ + GT(12, 13), + /** + * LT = 14; + */ + LT(13, 14), + /** + * GE = 15; + */ + GE(14, 15), + /** + * LE = 16; + */ + LE(15, 16), + /** + * EQEQ = 17; + */ + EQEQ(16, 17), + /** + * EXCLEQ = 18; + */ + EXCLEQ(17, 18), + /** + * EQEQEQ = 19; + */ + EQEQEQ(18, 19), + /** + * EXCLEQEQ = 20; + */ + EXCLEQEQ(19, 20), + /** + * ANDAND = 21; + */ + ANDAND(20, 21), + /** + * OROR = 22; + */ + OROR(21, 22), + /** + * EQ = 23; + */ + EQ(22, 23), + /** + * PLUSEQ = 24; + */ + PLUSEQ(23, 24), + /** + * MINUSEQ = 25; + */ + MINUSEQ(24, 25), + /** + * MULEQ = 26; + */ + MULEQ(25, 26), + /** + * DIVEQ = 27; + */ + DIVEQ(26, 27), + /** + * MODEQ = 28; + */ + MODEQ(27, 28), + /** + * ARRAY_ACCESS = 29; + */ + ARRAY_ACCESS(28, 29), + /** + * INVOKE = 30; + */ + INVOKE(29, 30), + ; + + /** + * UNARY_PLUS = 1; + */ + public static final int UNARY_PLUS_VALUE = 1; + /** + * UNARY_MINUS = 2; + */ + public static final int UNARY_MINUS_VALUE = 2; + /** + * EXCL = 3; + */ + public static final int EXCL_VALUE = 3; + /** + * PREFIX_INCREMENT = 4; + */ + public static final int PREFIX_INCREMENT_VALUE = 4; + /** + * POSTFIX_INCREMENT = 5; + */ + public static final int POSTFIX_INCREMENT_VALUE = 5; + /** + * PREFIX_DECREMENT = 6; + */ + public static final int PREFIX_DECREMENT_VALUE = 6; + /** + * POSTFIX_DECREMENT = 7; + */ + public static final int POSTFIX_DECREMENT_VALUE = 7; + /** + * BINARY_PLUS = 8; + */ + public static final int BINARY_PLUS_VALUE = 8; + /** + * BINARY_MINUS = 9; + */ + public static final int BINARY_MINUS_VALUE = 9; + /** + * MUL = 10; + */ + public static final int MUL_VALUE = 10; + /** + * DIV = 11; + */ + public static final int DIV_VALUE = 11; + /** + * MOD = 12; + */ + public static final int MOD_VALUE = 12; + /** + * GT = 13; + */ + public static final int GT_VALUE = 13; + /** + * LT = 14; + */ + public static final int LT_VALUE = 14; + /** + * GE = 15; + */ + public static final int GE_VALUE = 15; + /** + * LE = 16; + */ + public static final int LE_VALUE = 16; + /** + * EQEQ = 17; + */ + public static final int EQEQ_VALUE = 17; + /** + * EXCLEQ = 18; + */ + public static final int EXCLEQ_VALUE = 18; + /** + * EQEQEQ = 19; + */ + public static final int EQEQEQ_VALUE = 19; + /** + * EXCLEQEQ = 20; + */ + public static final int EXCLEQEQ_VALUE = 20; + /** + * ANDAND = 21; + */ + public static final int ANDAND_VALUE = 21; + /** + * OROR = 22; + */ + public static final int OROR_VALUE = 22; + /** + * EQ = 23; + */ + public static final int EQ_VALUE = 23; + /** + * PLUSEQ = 24; + */ + public static final int PLUSEQ_VALUE = 24; + /** + * MINUSEQ = 25; + */ + public static final int MINUSEQ_VALUE = 25; + /** + * MULEQ = 26; + */ + public static final int MULEQ_VALUE = 26; + /** + * DIVEQ = 27; + */ + public static final int DIVEQ_VALUE = 27; + /** + * MODEQ = 28; + */ + public static final int MODEQ_VALUE = 28; + /** + * ARRAY_ACCESS = 29; + */ + public static final int ARRAY_ACCESS_VALUE = 29; + /** + * INVOKE = 30; + */ + public static final int INVOKE_VALUE = 30; + + + public final int getNumber() { return value; } + + public static IrDynamicOperator valueOf(int value) { + switch (value) { + case 1: return UNARY_PLUS; + case 2: return UNARY_MINUS; + case 3: return EXCL; + case 4: return PREFIX_INCREMENT; + case 5: return POSTFIX_INCREMENT; + case 6: return PREFIX_DECREMENT; + case 7: return POSTFIX_DECREMENT; + case 8: return BINARY_PLUS; + case 9: return BINARY_MINUS; + case 10: return MUL; + case 11: return DIV; + case 12: return MOD; + case 13: return GT; + case 14: return LT; + case 15: return GE; + case 16: return LE; + case 17: return EQEQ; + case 18: return EXCLEQ; + case 19: return EQEQEQ; + case 20: return EXCLEQEQ; + case 21: return ANDAND; + case 22: return OROR; + case 23: return EQ; + case 24: return PLUSEQ; + case 25: return MINUSEQ; + case 26: return MULEQ; + case 27: return DIVEQ; + case 28: return MODEQ; + case 29: return ARRAY_ACCESS; + case 30: return INVOKE; + default: return null; + } + } + + public static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap + internalValueMap = + new org.jetbrains.kotlin.protobuf.Internal.EnumLiteMap() { + public IrDynamicOperator findValueByNumber(int number) { + return IrDynamicOperator.valueOf(number); + } + }; + + private final int value; + + private IrDynamicOperator(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator) + } + + private int bitField0_; + public static final int OPERATOR_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator operator_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator getOperator() { + return operator_; + } + + public static final int RECEIVER_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression receiver_; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getReceiver() { + return receiver_; + } + + public static final int ARGUMENT_FIELD_NUMBER = 3; + private java.util.List argument_; + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public java.util.List getArgumentList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public java.util.List + getArgumentOrBuilderList() { + return argument_; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .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(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpressionOrBuilder getArgumentOrBuilder( + int index) { + return argument_.get(index); + } + + private void initFields() { + operator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS; + receiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + argument_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasOperator()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasReceiver()) { + memoizedIsInitialized = 0; + return false; + } + if (!getReceiver().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getArgumentCount(); i++) { + if (!getArgument(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeEnum(1, operator_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, receiver_); + } + for (int i = 0; i < argument_.size(); i++) { + output.writeMessage(3, argument_.get(i)); + } + output.writeRawBytes(unknownFields); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeEnumSize(1, operator_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, receiver_); + } + for (int i = 0; i < argument_.size(); i++) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, argument_.get(i)); + } + size += unknownFields.size(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression 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.IrDynamicOperatorExpression parseFrom( + org.jetbrains.kotlin.protobuf.ByteString data, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression 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.IrDynamicOperatorExpression parseFrom( + byte[] data, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression 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.IrDynamicOperatorExpression parseFrom( + java.io.InputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression 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.IrDynamicOperatorExpression parseDelimitedFrom( + java.io.InputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression 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.IrDynamicOperatorExpression parseFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression} + */ + public static final class Builder extends + org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression, Builder> + implements + // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression) + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpressionOrBuilder { + // Construct using org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.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.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS; + bitField0_ = (bitField0_ & ~0x00000001); + receiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression getDefaultInstanceForType() { + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.getDefaultInstance(); + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression build() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression buildPartial() { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression result = new org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.operator_ = operator_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.receiver_ = receiver_; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + argument_ = java.util.Collections.unmodifiableList(argument_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.argument_ = argument_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression other) { + if (other == org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.getDefaultInstance()) return this; + if (other.hasOperator()) { + setOperator(other.getOperator()); + } + if (other.hasReceiver()) { + mergeReceiver(other.getReceiver()); + } + if (!other.argument_.isEmpty()) { + if (argument_.isEmpty()) { + argument_ = other.argument_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureArgumentIsMutable(); + argument_.addAll(other.argument_); + } + + } + setUnknownFields( + getUnknownFields().concat(other.unknownFields)); + return this; + } + + public final boolean isInitialized() { + if (!hasOperator()) { + + return false; + } + if (!hasReceiver()) { + + return false; + } + if (!getReceiver().isInitialized()) { + + return false; + } + for (int i = 0; i < getArgumentCount(); i++) { + if (!getArgument(i).isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + org.jetbrains.kotlin.protobuf.CodedInputStream input, + org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression 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.IrDynamicOperatorExpression) 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.IrDynamicOperatorExpression.IrDynamicOperator operator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS; + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator getOperator() { + return operator_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public Builder setOperator(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + operator_ = value; + + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression.IrDynamicOperator operator = 1; + */ + public Builder clearOperator() { + bitField0_ = (bitField0_ & ~0x00000001); + operator_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS; + + 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(); + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public boolean hasReceiver() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression getReceiver() { + return receiver_; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public Builder setReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (value == null) { + throw new NullPointerException(); + } + receiver_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public Builder setReceiver( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.Builder builderForValue) { + receiver_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public Builder mergeReceiver(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + 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_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression receiver = 2; + */ + public Builder clearReceiver() { + receiver_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrExpression.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + private java.util.List argument_ = + java.util.Collections.emptyList(); + private void ensureArgumentIsMutable() { + if (!((bitField0_ & 0x00000004) == 0x00000004)) { + argument_ = new java.util.ArrayList(argument_); + bitField0_ |= 0x00000004; + } + } + + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public java.util.List getArgumentList() { + return java.util.Collections.unmodifiableList(argument_); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + public int getArgumentCount() { + return argument_.size(); + } + /** + * repeated .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(int index) { + return argument_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + 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 = 3; + */ + 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 = 3; + */ + 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 = 3; + */ + 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 = 3; + */ + 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 = 3; + */ + 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 = 3; + */ + 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 = 3; + */ + public Builder clearArgument() { + argument_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrExpression argument = 3; + */ + 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.IrDynamicOperatorExpression) + } + + static { + defaultInstance = new IrDynamicOperatorExpression(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression) + } + public interface IrOperationOrBuilder extends // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation) org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { @@ -34766,6 +36330,24 @@ public final class IrKlibProtoBuf { * 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(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + boolean hasDynamicMember(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression getDynamicMember(); + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + boolean hasDynamicOperator(); + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression getDynamicOperator(); } /** * Protobuf type {@code org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation} @@ -35186,6 +36768,32 @@ public final class IrKlibProtoBuf { operationCase_ = 28; break; } + case 234: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.Builder subBuilder = null; + if (operationCase_ == 29) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 29; + break; + } + case 242: { + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.Builder subBuilder = null; + if (operationCase_ == 30) { + subBuilder = ((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression) operation_).toBuilder(); + } + operation_ = input.readMessage(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression) operation_); + operation_ = subBuilder.buildPartial(); + } + operationCase_ = 30; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -35252,6 +36860,8 @@ public final class IrKlibProtoBuf { VARARG(26), WHEN(27), WHILE(28), + DYNAMIC_MEMBER(29), + DYNAMIC_OPERATOR(30), OPERATION_NOT_SET(0); private int value = 0; private OperationCase(int value) { @@ -35287,6 +36897,8 @@ public final class IrKlibProtoBuf { case 26: return VARARG; case 27: return WHEN; case 28: return WHILE; + case 29: return DYNAMIC_MEMBER; + case 30: return DYNAMIC_OPERATOR; case 0: return OPERATION_NOT_SET; default: throw new java.lang.IllegalArgumentException( "Value is undefined for this oneof enum."); @@ -35779,6 +37391,40 @@ public final class IrKlibProtoBuf { return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile.getDefaultInstance(); } + public static final int DYNAMIC_MEMBER_FIELD_NUMBER = 29; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + public boolean hasDynamicMember() { + return operationCase_ == 29; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression getDynamicMember() { + if (operationCase_ == 29) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.getDefaultInstance(); + } + + public static final int DYNAMIC_OPERATOR_FIELD_NUMBER = 30; + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public boolean hasDynamicOperator() { + return operationCase_ == 30; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression getDynamicOperator() { + if (operationCase_ == 30) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.getDefaultInstance(); + } + private void initFields() { } private byte memoizedIsInitialized = -1; @@ -35955,6 +37601,18 @@ public final class IrKlibProtoBuf { return false; } } + if (hasDynamicMember()) { + if (!getDynamicMember().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDynamicOperator()) { + if (!getDynamicOperator().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } memoizedIsInitialized = 1; return true; } @@ -36046,6 +37704,12 @@ public final class IrKlibProtoBuf { if (operationCase_ == 28) { output.writeMessage(28, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) operation_); } + if (operationCase_ == 29) { + output.writeMessage(29, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression) operation_); + } + if (operationCase_ == 30) { + output.writeMessage(30, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression) operation_); + } output.writeRawBytes(unknownFields); } @@ -36167,6 +37831,14 @@ public final class IrKlibProtoBuf { size += org.jetbrains.kotlin.protobuf.CodedOutputStream .computeMessageSize(28, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrWhile) operation_); } + if (operationCase_ == 29) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(29, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression) operation_); + } + if (operationCase_ == 30) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(30, (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression) operation_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -36375,6 +38047,12 @@ public final class IrKlibProtoBuf { if (operationCase_ == 28) { result.operation_ = operation_; } + if (operationCase_ == 29) { + result.operation_ = operation_; + } + if (operationCase_ == 30) { + result.operation_ = operation_; + } result.bitField0_ = to_bitField0_; result.operationCase_ = operationCase_; return result; @@ -36495,6 +38173,14 @@ public final class IrKlibProtoBuf { mergeWhile(other.getWhile()); break; } + case DYNAMIC_MEMBER: { + mergeDynamicMember(other.getDynamicMember()); + break; + } + case DYNAMIC_OPERATOR: { + mergeDynamicOperator(other.getDynamicOperator()); + break; + } case OPERATION_NOT_SET: { break; } @@ -36673,6 +38359,18 @@ public final class IrKlibProtoBuf { return false; } } + if (hasDynamicMember()) { + if (!getDynamicMember().isInitialized()) { + + return false; + } + } + if (hasDynamicOperator()) { + if (!getDynamicOperator().isInitialized()) { + + return false; + } + } return true; } @@ -38501,6 +40199,134 @@ public final class IrKlibProtoBuf { return this; } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + public boolean hasDynamicMember() { + return operationCase_ == 29; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression getDynamicMember() { + if (operationCase_ == 29) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + public Builder setDynamicMember(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 29; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + public Builder setDynamicMember( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 29; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + public Builder mergeDynamicMember(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression value) { + if (operationCase_ == 29 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicMemberExpression) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 29; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicMemberExpression dynamic_member = 29; + */ + public Builder clearDynamicMember() { + if (operationCase_ == 29) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public boolean hasDynamicOperator() { + return operationCase_ == 30; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression getDynamicOperator() { + if (operationCase_ == 30) { + return (org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression) operation_; + } + return org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.getDefaultInstance(); + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public Builder setDynamicOperator(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression value) { + if (value == null) { + throw new NullPointerException(); + } + operation_ = value; + + operationCase_ = 30; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public Builder setDynamicOperator( + org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.Builder builderForValue) { + operation_ = builderForValue.build(); + + operationCase_ = 30; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public Builder mergeDynamicOperator(org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression value) { + if (operationCase_ == 30 && + operation_ != org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.getDefaultInstance()) { + operation_ = org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression.newBuilder((org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrKlibProtoBuf.IrDynamicOperatorExpression) operation_) + .mergeFrom(value).buildPartial(); + } else { + operation_ = value; + } + + operationCase_ = 30; + return this; + } + /** + * optional .org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrDynamicOperatorExpression dynamic_operator = 30; + */ + public Builder clearDynamicOperator() { + if (operationCase_ == 30) { + operationCase_ = 0; + operation_ = null; + + } + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.IrOperation) } 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 index 9e5a680d6f1..772783cd94d 100644 --- 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 @@ -566,6 +566,59 @@ abstract class IrModuleDeserializer( return loop } + private fun deserializeDynamicMemberExpression(proto: IrKlibProtoBuf.IrDynamicMemberExpression, start: Int, end: Int, type: IrType) = + IrDynamicMemberExpressionImpl(start, end, type, deserializeString(proto.memberName), deserializeExpression(proto.receiver)) + + private fun deserializeDynamicOperatorExpression(proto: IrKlibProtoBuf.IrDynamicOperatorExpression, start: Int, end: Int, type: IrType) = + IrDynamicOperatorExpressionImpl(start, end, type, deserializeDynamicOperator(proto.operator)).apply { + receiver = deserializeExpression(proto.receiver) + proto.argumentList.mapTo(arguments) { deserializeExpression(it) } + } + + private fun deserializeDynamicOperator(operator: IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator) = when (operator) { + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS -> IrDynamicOperator.UNARY_PLUS + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_MINUS -> IrDynamicOperator.UNARY_MINUS + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCL -> IrDynamicOperator.EXCL + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_INCREMENT -> IrDynamicOperator.PREFIX_INCREMENT + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT -> IrDynamicOperator.PREFIX_DECREMENT + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT -> IrDynamicOperator.POSTFIX_INCREMENT + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_DECREMENT -> IrDynamicOperator.POSTFIX_DECREMENT + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_PLUS -> IrDynamicOperator.BINARY_PLUS + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_MINUS -> IrDynamicOperator.BINARY_MINUS + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MUL -> IrDynamicOperator.MUL + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.DIV -> IrDynamicOperator.DIV + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MOD -> IrDynamicOperator.MOD + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.GT -> IrDynamicOperator.GT + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.LT -> IrDynamicOperator.LT + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.GE -> IrDynamicOperator.GE + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.LE -> IrDynamicOperator.LE + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ -> IrDynamicOperator.EQEQ + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ -> IrDynamicOperator.EXCLEQ + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ -> IrDynamicOperator.EQEQEQ + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ -> IrDynamicOperator.EXCLEQEQ + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND -> IrDynamicOperator.ANDAND + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.OROR -> IrDynamicOperator.OROR + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.EQ -> IrDynamicOperator.EQ + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.PLUSEQ -> IrDynamicOperator.PLUSEQ + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MINUSEQ -> IrDynamicOperator.MINUSEQ + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MULEQ -> IrDynamicOperator.MULEQ + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.DIVEQ -> IrDynamicOperator.DIVEQ + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.MODEQ -> IrDynamicOperator.MODEQ + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.ARRAY_ACCESS -> IrDynamicOperator.ARRAY_ACCESS + + IrKlibProtoBuf.IrDynamicOperatorExpression.IrDynamicOperator.INVOKE -> IrDynamicOperator.INVOKE + } + private fun deserializeBreak(proto: IrKlibProtoBuf.IrBreak, start: Int, end: Int, type: IrType): IrBreak { val label = if (proto.hasLabel()) deserializeString(proto.label) else null val loopId = proto.loopId @@ -670,6 +723,10 @@ abstract class IrModuleDeserializer( -> deserializeWhen(proto.`when`, start, end, type) WHILE -> deserializeWhile(proto.`while`, start, end, type) + DYNAMIC_MEMBER + -> deserializeDynamicMemberExpression(proto.dynamicMember, start, end, type) + DYNAMIC_OPERATOR + -> deserializeDynamicOperatorExpression(proto.dynamicOperator, start, end, type) OPERATION_NOT_SET -> error("Expression deserialization not implemented: ${proto.operationCase}") } 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 index d7ac58dff6c..444069f2232 100644 --- 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 @@ -668,6 +668,68 @@ internal class IrModuleSerializer( 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) } @@ -743,6 +805,8 @@ internal class IrModuleSerializer( 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)}.") } 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 index 8777b53c5fa..243979c357d 100644 --- 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 @@ -394,6 +394,54 @@ message IrWhile { required Loop loop = 1; } +/* ------ Dynamic expression --------------------------------------------- */ + +message IrDynamicMemberExpression { + required String memberName = 1; + required IrExpression receiver = 2; +} + +message IrDynamicOperatorExpression { + enum IrDynamicOperator { + UNARY_PLUS = 1; + UNARY_MINUS = 2; + EXCL = 3; + PREFIX_INCREMENT = 4; + POSTFIX_INCREMENT = 5; + PREFIX_DECREMENT = 6; + POSTFIX_DECREMENT = 7; + + BINARY_PLUS = 8; + BINARY_MINUS = 9; + MUL = 10; + DIV = 11; + MOD = 12; + GT = 13; + LT = 14; + GE = 15; + LE = 16; + EQEQ = 17; + EXCLEQ = 18; + EQEQEQ = 19; + EXCLEQEQ = 20; + ANDAND = 21; + OROR = 22; + + EQ = 23; + PLUSEQ = 24; + MINUSEQ = 25; + MULEQ = 26; + DIVEQ = 27; + MODEQ = 28; + + ARRAY_ACCESS = 29; + INVOKE = 30; + } + required IrDynamicOperator operator = 1; + required IrExpression receiver = 2; + repeated IrExpression argument = 3; +} + // TODO: we need an extension mechanism to accomodate new // IR operators in upcoming releases. message IrOperation { @@ -426,6 +474,8 @@ message IrOperation { IrVararg vararg = 26; IrWhen when = 27; IrWhile while = 28; + IrDynamicMemberExpression dynamic_member = 29; + IrDynamicOperatorExpression dynamic_operator = 30; } }