File _service:tar_scm_kernel_repo:0006-fix-CVE-2022-... of Package protobuf

File _service:tar_scm_kernel_repo:0006-fix-CVE-2022-3171.patch of Package protobuf

From 11ceafebd2234b5c3e559f6ae3d433bf0ed7f667 Mon Sep 17 00:00:00 2001
From: chengzrz <czrzrichard@gmail.com>
Date: Mon, 17 Oct 2022 21:43:05 +0800
Subject: [PATCH] fix cve-2022-3171

Signed-off-by: chengzrz <czrzrichard@gmail.com>
---
 .../com/google/protobuf/AbstractMessage.java | 27 +-
 .../com/google/protobuf/ArrayDecoders.java | 146 +++---
 .../com/google/protobuf/BinaryReader.java | 32 +-
 .../protobuf/CodedInputStreamReader.java | 51 +-
 .../DescriptorMessageInfoFactory.java | 4 +-
 .../com/google/protobuf/DynamicMessage.java | 5 +-
 .../com/google/protobuf/ExtensionSchema.java | 1 +
 .../google/protobuf/ExtensionSchemaFull.java | 5 +-
 .../google/protobuf/ExtensionSchemaLite.java | 52 +-
 .../java/com/google/protobuf/FieldSet.java | 63 ++-
 .../google/protobuf/GeneratedMessageLite.java | 169 ++++--
 .../google/protobuf/GeneratedMessageV3.java | 110 +++-
 .../google/protobuf/MessageLiteToString.java | 117 +++--
 .../google/protobuf/MessageReflection.java | 439 +++++++++++++++-
 .../com/google/protobuf/MessageSchema.java | 485 +++++++++++-------
 .../com/google/protobuf/MessageSetSchema.java | 17 +-
 .../protobuf/NewInstanceSchemaLite.java | 5 +-
 .../main/java/com/google/protobuf/Reader.java | 8 +
 .../java/com/google/protobuf/SchemaUtil.java | 30 +-
 .../java/com/google/protobuf/TextFormat.java | 2 +-
 .../google/protobuf/UnknownFieldSetLite.java | 38 +-
 .../protobuf/UnknownFieldSetLiteSchema.java | 12 +-
 .../java/com/google/protobuf/LiteTest.java | 36 +-
 .../google/protobuf/util/FieldMaskTree.java | 10 +-
 .../protobuf/compiler/java/java_enum_field.cc | 94 ++--
 .../protobuf/compiler/java/java_enum_field.h | 94 ++--
 .../protobuf/compiler/java/java_field.cc | 4 +-
 .../protobuf/compiler/java/java_field.h | 5 +-
 .../protobuf/compiler/java/java_map_field.cc | 30 +-
 .../protobuf/compiler/java/java_map_field.h | 34 +-
 .../protobuf/compiler/java/java_message.cc | 220 ++------
 .../compiler/java/java_message_builder.cc | 163 ++++--
 .../compiler/java/java_message_builder.h | 5 +
 .../compiler/java/java_message_field.cc | 126 ++---
 .../compiler/java/java_message_field.h | 87 ++--
 .../compiler/java/java_primitive_field.cc | 66 +--
 .../compiler/java/java_primitive_field.h | 90 ++--
 .../compiler/java/java_string_field.cc | 59 +--
 .../compiler/java/java_string_field.h | 87 ++--
 39 files changed, 1907 insertions(+), 1121 deletions(-)

diff --git a/java/core/src/main/java/com/google/protobuf/AbstractMessage.java b/java/core/src/main/java/com/google/protobuf/AbstractMessage.java
index 1364fce..ebf4318 100644
--- a/java/core/src/main/java/com/google/protobuf/AbstractMessage.java
+++ b/java/core/src/main/java/com/google/protobuf/AbstractMessage.java
@@ -426,27 +426,22 @@ public abstract class AbstractMessage
 throws IOException {
 boolean discardUnknown = input.shouldDiscardUnknownFields();
 final UnknownFieldSet.Builder unknownFields =
- discardUnknown ? null : UnknownFieldSet.newBuilder(getUnknownFields());
- while (true) {
- final int tag = input.readTag();
- if (tag == 0) {
- break;
- }
-
- MessageReflection.BuilderAdapter builderAdapter =
- new MessageReflection.BuilderAdapter(this);
- if (!MessageReflection.mergeFieldFrom(
- input, unknownFields, extensionRegistry, getDescriptorForType(), builderAdapter, tag)) {
- // end group tag
- break;
- }
- }
+ discardUnknown ? null : getUnknownFieldSetBuilder();
+ MessageReflection.mergeMessageFrom(this, unknownFields, input, extensionRegistry);
 if (unknownFields != null) {
- setUnknownFields(unknownFields.build());
+ setUnknownFieldSetBuilder(unknownFields);
 }
 return (BuilderType) this;
 }
 
+ protected UnknownFieldSet.Builder getUnknownFieldSetBuilder() {
+ return UnknownFieldSet.newBuilder(getUnknownFields());
+ }
+
+ protected void setUnknownFieldSetBuilder(final UnknownFieldSet.Builder builder) {
+ setUnknownFields(builder.build());
+ }
+
 @Override
 public BuilderType mergeUnknownFields(final UnknownFieldSet unknownFields) {
 setUnknownFields(
diff --git a/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java b/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java
index 1217e11..39b7927 100644
--- a/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java
+++ b/java/core/src/main/java/com/google/protobuf/ArrayDecoders.java
@@ -234,6 +234,29 @@ final class ArrayDecoders {
 @SuppressWarnings({"unchecked", "rawtypes"})
 static int decodeMessageField(
 Schema schema, byte[] data, int position, int limit, Registers registers) throws IOException {
+ Object msg = schema.newInstance();
+ int offset = mergeMessageField(msg, schema, data, position, limit, registers);
+ schema.makeImmutable(msg);
+ registers.object1 = msg;
+ return offset;
+ }
+
+ /** Decodes a group value. */
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ static int decodeGroupField(
+ Schema schema, byte[] data, int position, int limit, int endGroup, Registers registers)
+ throws IOException {
+ Object msg = schema.newInstance();
+ int offset = mergeGroupField(msg, schema, data, position, limit, endGroup, registers);
+ schema.makeImmutable(msg);
+ registers.object1 = msg;
+ return offset;
+ }
+
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ static int mergeMessageField(
+ Object msg, Schema schema, byte[] data, int position, int limit, Registers registers)
+ throws IOException {
 int length = data[position++];
 if (length < 0) {
 position = decodeVarint32(length, data, position, registers);
@@ -242,27 +265,28 @@ final class ArrayDecoders {
 if (length < 0 || length > limit - position) {
 throw InvalidProtocolBufferException.truncatedMessage();
 }
- Object result = schema.newInstance();
- schema.mergeFrom(result, data, position, position + length, registers);
- schema.makeImmutable(result);
- registers.object1 = result;
+ schema.mergeFrom(msg, data, position, position + length, registers);
+ registers.object1 = msg;
 return position + length;
 }
 
- /** Decodes a group value. */
 @SuppressWarnings({"unchecked", "rawtypes"})
- static int decodeGroupField(
- Schema schema, byte[] data, int position, int limit, int endGroup, Registers registers)
+ static int mergeGroupField(
+ Object msg,
+ Schema schema,
+ byte[] data,
+ int position,
+ int limit,
+ int endGroup,
+ Registers registers)
 throws IOException {
 // A group field must has a MessageSchema (the only other subclass of Schema is MessageSetSchema
 // and it can't be used in group fields).
 final MessageSchema messageSchema = (MessageSchema) schema;
- Object result = messageSchema.newInstance();
 // It's OK to directly use parseProto2Message since proto3 doesn't have group.
 final int endPosition =
- messageSchema.parseProto2Message(result, data, position, limit, endGroup, registers);
- messageSchema.makeImmutable(result);
- registers.object1 = result;
+ messageSchema.parseProto2Message(msg, data, position, limit, endGroup, registers);
+ registers.object1 = msg;
 return endPosition;
 }
 
@@ -847,26 +871,19 @@ final class ArrayDecoders {
 break;
 }
 case ENUM:
- {
- IntArrayList list = new IntArrayList();
- position = decodePackedVarint32List(data, position, list, registers);
- UnknownFieldSetLite unknownFields = message.unknownFields;
- if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
- unknownFields = null;
- }
- unknownFields =
- SchemaUtil.filterUnknownEnumList(
- fieldNumber,
- list,
- extension.descriptor.getEnumType(),
- unknownFields,
- unknownFieldSchema);
- if (unknownFields != null) {
- message.unknownFields = unknownFields;
+ {
+ IntArrayList list = new IntArrayList();
+ position = decodePackedVarint32List(data, position, list, registers);
+ SchemaUtil.filterUnknownEnumList(
+ message,
+ fieldNumber,
+ list,
+ extension.descriptor.getEnumType(),
+ null,
+ unknownFieldSchema);
+ extensions.setField(extension.descriptor, list);
+ break;
 }
- extensions.setField(extension.descriptor, list);
- break;
- }
 default:
 throw new IllegalStateException(
 "Type cannot be packed: " + extension.descriptor.getLiteType());
@@ -878,13 +895,8 @@ final class ArrayDecoders {
 position = decodeVarint32(data, position, registers);
 Object enumValue = extension.descriptor.getEnumType().findValueByNumber(registers.int1);
 if (enumValue == null) {
- UnknownFieldSetLite unknownFields = ((GeneratedMessageLite) message).unknownFields;
- if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
- unknownFields = UnknownFieldSetLite.newInstance();
- ((GeneratedMessageLite) message).unknownFields = unknownFields;
- }
 SchemaUtil.storeUnknownEnum(
- fieldNumber, registers.int1, unknownFields, unknownFieldSchema);
+ message, fieldNumber, registers.int1, null, unknownFieldSchema);
 return position;
 }
 // Note, we store the integer value instead of the actual enum object in FieldSet.
@@ -941,20 +953,45 @@ final class ArrayDecoders {
 value = registers.object1;
 break;
 case GROUP:
- final int endTag = (fieldNumber << 3) | WireFormat.WIRETYPE_END_GROUP;
- position = decodeGroupField(
- Protobuf.getInstance().schemaFor(extension.getMessageDefaultInstance().getClass()),
- data, position, limit, endTag, registers);
- value = registers.object1;
- break;
-
+ {
+ final int endTag = (fieldNumber << 3) | WireFormat.WIRETYPE_END_GROUP;
+ final Schema fieldSchema =
+ Protobuf.getInstance()
+ .schemaFor(extension.getMessageDefaultInstance().getClass());
+ if (extension.isRepeated()) {
+ position = decodeGroupField(fieldSchema, data, position, limit, endTag, registers);
+ extensions.addRepeatedField(extension.descriptor, registers.object1);
+ } else {
+ Object oldValue = extensions.getField(extension.descriptor);
+ if (oldValue == null) {
+ oldValue = fieldSchema.newInstance();
+ extensions.setField(extension.descriptor, oldValue);
+ }
+ position =
+ mergeGroupField(
+ oldValue, fieldSchema, data, position, limit, endTag, registers);
+ }
+ return position;
+ }
 case MESSAGE:
- position = decodeMessageField(
- Protobuf.getInstance().schemaFor(extension.getMessageDefaultInstance().getClass()),
- data, position, limit, registers);
- value = registers.object1;
- break;
-
+ {
+ final Schema fieldSchema =
+ Protobuf.getInstance()
+ .schemaFor(extension.getMessageDefaultInstance().getClass());
+ if (extension.isRepeated()) {
+ position = decodeMessageField(fieldSchema, data, position, limit, registers);
+ extensions.addRepeatedField(extension.descriptor, registers.object1);
+ } else {
+ Object oldValue = extensions.getField(extension.descriptor);
+ if (oldValue == null) {
+ oldValue = fieldSchema.newInstance();
+ extensions.setField(extension.descriptor, oldValue);
+ }
+ position =
+ mergeMessageField(oldValue, fieldSchema, data, position, limit, registers);
+ }
+ return position;
+ }
 case ENUM:
 throw new IllegalStateException("Shouldn't reach here.");
 }
@@ -962,17 +999,6 @@ final class ArrayDecoders {
 if (extension.isRepeated()) {
 extensions.addRepeatedField(extension.descriptor, value);
 } else {
- switch (extension.getLiteType()) {
- case MESSAGE:
- case GROUP:
- Object oldValue = extensions.getField(extension.descriptor);
- if (oldValue != null) {
- value = Internal.mergeMessage(oldValue, value);
- }
- break;
- default:
- break;
- }
 extensions.setField(extension.descriptor, value);
 }
 }
diff --git a/java/core/src/main/java/com/google/protobuf/BinaryReader.java b/java/core/src/main/java/com/google/protobuf/BinaryReader.java
index d64574c..3a0e04d 100644
--- a/java/core/src/main/java/com/google/protobuf/BinaryReader.java
+++ b/java/core/src/main/java/com/google/protobuf/BinaryReader.java
@@ -247,6 +247,15 @@ abstract class BinaryReader implements Reader {
 
 private <T> T readMessage(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
 throws IOException {
+ T newInstance = schema.newInstance();
+ mergeMessageField(newInstance, schema, extensionRegistry);
+ schema.makeImmutable(newInstance);
+ return newInstance;
+ }
+
+ @Override
+ public <T> void mergeMessageField(
+ T target, Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException {
 int size = readVarint32();
 requireBytes(size);
 
@@ -256,15 +265,10 @@ abstract class BinaryReader implements Reader {
 limit = newLimit;
 
 try {
- // Allocate and read the message.
- T message = schema.newInstance();
- schema.mergeFrom(message, this, extensionRegistry);
- schema.makeImmutable(message);
-
+ schema.mergeFrom(target, this, extensionRegistry);
 if (pos != newLimit) {
 throw InvalidProtocolBufferException.parseFailure();
 }
- return message;
 } finally {
 // Restore the limit.
 limit = prevLimit;
@@ -287,19 +291,23 @@ abstract class BinaryReader implements Reader {
 
 private <T> T readGroup(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
 throws IOException {
+ T newInstance = schema.newInstance();
+ mergeGroupField(newInstance, schema, extensionRegistry);
+ schema.makeImmutable(newInstance);
+ return newInstance;
+ }
+
+ @Override
+ public <T> void mergeGroupField(
+ T target, Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException {
 int prevEndGroupTag = endGroupTag;
 endGroupTag = WireFormat.makeTag(WireFormat.getTagFieldNumber(tag), WIRETYPE_END_GROUP);
 
 try {
- // Allocate and read the message.
- T message = schema.newInstance();
- schema.mergeFrom(message, this, extensionRegistry);
- schema.makeImmutable(message);
-
+ schema.mergeFrom(target, this, extensionRegistry);
 if (tag != endGroupTag) {
 throw InvalidProtocolBufferException.parseFailure();
 }
- return message;
 } finally {
 // Restore the old end group tag.
 endGroupTag = prevEndGroupTag;
diff --git a/java/core/src/main/java/com/google/protobuf/CodedInputStreamReader.java b/java/core/src/main/java/com/google/protobuf/CodedInputStreamReader.java
index 7658f62..1d992d7 100644
--- a/java/core/src/main/java/com/google/protobuf/CodedInputStreamReader.java
+++ b/java/core/src/main/java/com/google/protobuf/CodedInputStreamReader.java
@@ -197,9 +197,15 @@ final class CodedInputStreamReader implements Reader {
 return readGroup(schema, extensionRegistry);
 }
 
- // Should have the same semantics of CodedInputStream#readMessage()
- private <T> T readMessage(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
- throws IOException {
+ @Override
+ public <T> void mergeMessageField(
+ T target, Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException {
+ requireWireType(WIRETYPE_LENGTH_DELIMITED);
+ mergeMessageFieldInternal(target, schema, extensionRegistry);
+ }
+
+ private <T> void mergeMessageFieldInternal(
+ T target, Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException {
 int size = input.readUInt32();
 if (input.recursionDepth >= input.recursionLimit) {
 throw InvalidProtocolBufferException.recursionLimitExceeded();
@@ -207,39 +213,54 @@ final class CodedInputStreamReader implements Reader {
 
 // Push the new limit.
 final int prevLimit = input.pushLimit(size);
- // Allocate and read the message.
- T message = schema.newInstance();
 ++input.recursionDepth;
- schema.mergeFrom(message, this, extensionRegistry);
- schema.makeImmutable(message);
+ schema.mergeFrom(target, this, extensionRegistry);
 input.checkLastTagWas(0);
 --input.recursionDepth;
 // Restore the previous limit.
 input.popLimit(prevLimit);
- return message;
 }
 
- private <T> T readGroup(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ // Should have the same semantics of CodedInputStream#readMessage()
+ private <T> T readMessage(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
 throws IOException {
+ T newInstance = schema.newInstance();
+ mergeMessageFieldInternal(newInstance, schema, extensionRegistry);
+ schema.makeImmutable(newInstance);
+ return newInstance;
+ }
+
+ @Override
+ public <T> void mergeGroupField(
+ T target, Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException {
+ requireWireType(WIRETYPE_START_GROUP);
+ mergeGroupFieldInternal(target, schema, extensionRegistry);
+ }
+
+ private <T> void mergeGroupFieldInternal(
+ T target, Schema<T> schema, ExtensionRegistryLite extensionRegistry) throws IOException {
 int prevEndGroupTag = endGroupTag;
 endGroupTag = WireFormat.makeTag(WireFormat.getTagFieldNumber(tag), WIRETYPE_END_GROUP);
 
 try {
- // Allocate and read the message.
- T message = schema.newInstance();
- schema.mergeFrom(message, this, extensionRegistry);
- schema.makeImmutable(message);
-
+ schema.mergeFrom(target, this, extensionRegistry);
 if (tag != endGroupTag) {
 throw InvalidProtocolBufferException.parseFailure();
 }
- return message;
 } finally {
 // Restore the old end group tag.
 endGroupTag = prevEndGroupTag;
 }
 }
 
+ private <T> T readGroup(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ T newInstance = schema.newInstance();
+ mergeGroupFieldInternal(newInstance, schema, extensionRegistry);
+ schema.makeImmutable(newInstance);
+ return newInstance;
+ }
+
 @Override
 public ByteString readBytes() throws IOException {
 requireWireType(WIRETYPE_LENGTH_DELIMITED);
diff --git a/java/core/src/main/java/com/google/protobuf/DescriptorMessageInfoFactory.java b/java/core/src/main/java/com/google/protobuf/DescriptorMessageInfoFactory.java
index 7975136..21ded52 100644
--- a/java/core/src/main/java/com/google/protobuf/DescriptorMessageInfoFactory.java
+++ b/java/core/src/main/java/com/google/protobuf/DescriptorMessageInfoFactory.java
@@ -402,8 +402,8 @@ final class DescriptorMessageInfoFactory implements MessageInfoFactory {
 boolean enforceUtf8 = true;
 for (int i = 0; i < fieldDescriptors.size(); ++i) {
 FieldDescriptor fd = fieldDescriptors.get(i);
- if (fd.getContainingOneof() != null) {
- // Build a oneof member field.
+ if (fd.getContainingOneof() != null && !fd.getContainingOneof().isSynthetic()) {
+ // Build a oneof member field. But only if it is a real oneof, not a proto3 optional
 builder.withField(buildOneofMember(messageType, fd, oneofState, enforceUtf8, null));
 continue;
 }
diff --git a/java/core/src/main/java/com/google/protobuf/DynamicMessage.java b/java/core/src/main/java/com/google/protobuf/DynamicMessage.java
index 8beebba..51e6b0c 100644
--- a/java/core/src/main/java/com/google/protobuf/DynamicMessage.java
+++ b/java/core/src/main/java/com/google/protobuf/DynamicMessage.java
@@ -421,7 +421,10 @@ public final class DynamicMessage extends AbstractMessage {
 fields.makeImmutable();
 DynamicMessage result =
 new DynamicMessage(
- type, fields, java.util.Arrays.copyOf(oneofCases, oneofCases.length), unknownFields);
+ type,
+ fields,
+ java.util.Arrays.copyOf(oneofCases, oneofCases.length),
+ unknownFields);
 return result;
 }
 
diff --git a/java/core/src/main/java/com/google/protobuf/ExtensionSchema.java b/java/core/src/main/java/com/google/protobuf/ExtensionSchema.java
index 2eae22d..bd391a2 100644
--- a/java/core/src/main/java/com/google/protobuf/ExtensionSchema.java
+++ b/java/core/src/main/java/com/google/protobuf/ExtensionSchema.java
@@ -59,6 +59,7 @@ abstract class ExtensionSchema<T extends FieldSet.FieldDescriptorLite<T>> {
 * or UnknownFieldSetLite in lite runtime.
 */
 abstract <UT, UB> UB parseExtension(
+ Object containerMessage,
 Reader reader,
 Object extension,
 ExtensionRegistryLite extensionRegistry,
diff --git a/java/core/src/main/java/com/google/protobuf/ExtensionSchemaFull.java b/java/core/src/main/java/com/google/protobuf/ExtensionSchemaFull.java
index 9055851..9376e87 100644
--- a/java/core/src/main/java/com/google/protobuf/ExtensionSchemaFull.java
+++ b/java/core/src/main/java/com/google/protobuf/ExtensionSchemaFull.java
@@ -85,6 +85,7 @@ final class ExtensionSchemaFull extends ExtensionSchema<FieldDescriptor> {
 
 @Override
 <UT, UB> UB parseExtension(
+ Object containerMessage,
 Reader reader,
 Object extensionObject,
 ExtensionRegistryLite extensionRegistry,
@@ -202,7 +203,7 @@ final class ExtensionSchemaFull extends ExtensionSchema<FieldDescriptor> {
 } else {
 unknownFields =
 SchemaUtil.storeUnknownEnum(
- fieldNumber, number, unknownFields, unknownFieldSchema);
+ containerMessage, fieldNumber, number, unknownFields, unknownFieldSchema);
 }
 }
 value = enumList;
@@ -221,7 +222,7 @@ final class ExtensionSchemaFull extends ExtensionSchema<FieldDescriptor> {
 Object enumValue = extension.descriptor.getEnumType().findValueByNumber(number);
 if (enumValue == null) {
 return SchemaUtil.storeUnknownEnum(
- fieldNumber, number, unknownFields, unknownFieldSchema);
+ containerMessage, fieldNumber, number, unknownFields, unknownFieldSchema);
 }
 value = enumValue;
 } else {
diff --git a/java/core/src/main/java/com/google/protobuf/ExtensionSchemaLite.java b/java/core/src/main/java/com/google/protobuf/ExtensionSchemaLite.java
index 437cca2..7e20ed2 100644
--- a/java/core/src/main/java/com/google/protobuf/ExtensionSchemaLite.java
+++ b/java/core/src/main/java/com/google/protobuf/ExtensionSchemaLite.java
@@ -32,7 +32,6 @@ package com.google.protobuf;
 
 import com.google.protobuf.GeneratedMessageLite.ExtensionDescriptor;
 import java.io.IOException;
-import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -67,6 +66,7 @@ final class ExtensionSchemaLite extends ExtensionSchema<ExtensionDescriptor> {
 
 @Override
 <UT, UB> UB parseExtension(
+ Object containerMessage,
 Reader reader,
 Object extensionObject,
 ExtensionRegistryLite extensionRegistry,
@@ -178,6 +178,7 @@ final class ExtensionSchemaLite extends ExtensionSchema<ExtensionDescriptor> {
 reader.readEnumList(list);
 unknownFields =
 SchemaUtil.filterUnknownEnumList(
+ containerMessage,
 fieldNumber,
 list,
 extension.descriptor.getEnumType(),
@@ -199,7 +200,7 @@ final class ExtensionSchemaLite extends ExtensionSchema<ExtensionDescriptor> {
 Object enumValue = extension.descriptor.getEnumType().findValueByNumber(number);
 if (enumValue == null) {
 return SchemaUtil.storeUnknownEnum(
- fieldNumber, number, unknownFields, unknownFieldSchema);
+ containerMessage, fieldNumber, number, unknownFields, unknownFieldSchema);
 }
 // Note, we store the integer value instead of the actual enum object in FieldSet.
 // This is also different from full-runtime where we store EnumValueDescriptor.
@@ -253,12 +254,46 @@ final class ExtensionSchemaLite extends ExtensionSchema<ExtensionDescriptor> {
 value = reader.readString();
 break;
 case GROUP:
+ // Special case handling for non-repeated sub-messages: merge in-place rather than
+ // building up new sub-messages and merging those, which is too slow.
+ // TODO(b/249368670): clean this up
+ if (!extension.isRepeated()) {
+ Object oldValue = extensions.getField(extension.descriptor);
+ if (oldValue instanceof GeneratedMessageLite) {
+ Schema extSchema = Protobuf.getInstance().schemaFor(oldValue);
+ if (!((GeneratedMessageLite<?, ?>) oldValue).isMutable()) {
+ Object newValue = extSchema.newInstance();
+ extSchema.mergeFrom(newValue, oldValue);
+ extensions.setField(extension.descriptor, newValue);
+ oldValue = newValue;
+ }
+ reader.mergeGroupField(oldValue, extSchema, extensionRegistry);
+ return unknownFields;
+ }
+ }
 value =
 reader.readGroup(
 extension.getMessageDefaultInstance().getClass(), extensionRegistry);
 break;
 
 case MESSAGE:
+ // Special case handling for non-repeated sub-messages: merge in-place rather than
+ // building up new sub-messages and merging those, which is too slow.
+ // TODO(b/249368670): clean this up
+ if (!extension.isRepeated()) {
+ Object oldValue = extensions.getField(extension.descriptor);
+ if (oldValue instanceof GeneratedMessageLite) {
+ Schema extSchema = Protobuf.getInstance().schemaFor(oldValue);
+ if (!((GeneratedMessageLite<?, ?>) oldValue).isMutable()) {
+ Object newValue = extSchema.newInstance();
+ extSchema.mergeFrom(newValue, oldValue);
+ extensions.setField(extension.descriptor, newValue);
+ oldValue = newValue;
+ }
+ reader.mergeMessageField(oldValue, extSchema, extensionRegistry);
+ return unknownFields;
+ }
+ }
 value =
 reader.readMessage(
 extension.getMessageDefaultInstance().getClass(), extensionRegistry);
@@ -274,6 +309,7 @@ final class ExtensionSchemaLite extends ExtensionSchema<ExtensionDescriptor> {
 switch (extension.getLiteType()) {
 case MESSAGE:
 case GROUP:
+ // TODO(b/249368670): this shouldn't be reachable, clean this up
 Object oldValue = extensions.getField(extension.descriptor);
 if (oldValue != null) {
 value = Internal.mergeMessage(oldValue, value);
@@ -527,15 +563,13 @@ final class ExtensionSchemaLite extends ExtensionSchema<ExtensionDescriptor> {
 throws IOException {
 GeneratedMessageLite.GeneratedExtension<?, ?> extension =
 (GeneratedMessageLite.GeneratedExtension<?, ?>) extensionObject;
- Object value = extension.getMessageDefaultInstance().newBuilderForType().buildPartial();
 
- Reader reader = BinaryReader.newInstance(ByteBuffer.wrap(data.toByteArray()), true);
+ MessageLite.Builder builder = extension.getMessageDefaultInstance().newBuilderForType();
 
- Protobuf.getInstance().mergeFrom(value, reader, extensionRegistry);
- extensions.setField(extension.descriptor, value);
+ final CodedInputStream input = data.newCodedInput();
 
- if (reader.getFieldNumber() != Reader.READ_DONE) {
- throw InvalidProtocolBufferException.invalidEndTag();
- }
+ builder.mergeFrom(input, extensionRegistry);
+ extensions.setField(extension.descriptor, builder.buildPartial());
+ input.checkLastTagWas(0);
 }
 }
diff --git a/java/core/src/main/java/com/google/protobuf/FieldSet.java b/java/core/src/main/java/com/google/protobuf/FieldSet.java
index d52aede..e30cf90 100644
--- a/java/core/src/main/java/com/google/protobuf/FieldSet.java
+++ b/java/core/src/main/java/com/google/protobuf/FieldSet.java
@@ -39,6 +39,7 @@ import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 
 /**
 * A class which represents an arbitrary set of fields of some message type. This is used to
@@ -124,6 +125,12 @@ final class FieldSet<T extends FieldSet.FieldDescriptorLite<T>> {
 if (isImmutable) {
 return;
 }
+ for (int i = 0; i < fields.getNumArrayEntries(); ++i) {
+ Entry<T, Object> entry = fields.getArrayEntryAt(i);
+ if (entry.getValue() instanceof GeneratedMessageLite) {
+ ((GeneratedMessageLite<?, ?>) entry.getValue()).makeImmutable();
+ }
+ }
 fields.makeImmutable();
 isImmutable = true;
 }
@@ -933,8 +940,27 @@ final class FieldSet<T extends FieldSet.FieldDescriptorLite<T>> {
 this.isMutable = true;
 }
 
- /** Creates the FieldSet */
+ /**
+ * Creates the FieldSet
+ *
+ * @throws UninitializedMessageException if a message field is missing required fields.
+ */
 public FieldSet<T> build() {
+ return buildImpl(false);
+ }
+
+ /** Creates the FieldSet but does not validate that all required fields are present. */
+ public FieldSet<T> buildPartial() {
+ return buildImpl(true);
+ }
+
+ /**
+ * Creates the FieldSet.
+ *
+ * @param partial controls whether to do a build() or buildPartial() when converting submessage
+ * builders to messages.
+ */
+ private FieldSet<T> buildImpl(boolean partial) {
 if (fields.isEmpty()) {
 return FieldSet.emptySet();
 }
@@ -943,7 +969,7 @@ final class FieldSet<T extends FieldSet.FieldDescriptorLite<T>> {
 if (hasNestedBuilders) {
 // Make a copy of the fields map with all Builders replaced by Message.
 fieldsForBuild = cloneAllFieldsMap(fields, /* copyList */ false);
- replaceBuilders(fieldsForBuild);
+ replaceBuilders(fieldsForBuild, partial);
 }
 FieldSet<T> fieldSet = new FieldSet<>(fieldsForBuild);
 fieldSet.hasLazyField = hasLazyField;
@@ -951,22 +977,22 @@ final class FieldSet<T extends FieldSet.FieldDescriptorLite<T>> {
 }
 
 private static <T extends FieldDescriptorLite<T>> void replaceBuilders(
- SmallSortedMap<T, Object> fieldMap) {
+ SmallSortedMap<T, Object> fieldMap, boolean partial) {
 for (int i = 0; i < fieldMap.getNumArrayEntries(); i++) {
- replaceBuilders(fieldMap.getArrayEntryAt(i));
+ replaceBuilders(fieldMap.getArrayEntryAt(i), partial);
 }
 for (Map.Entry<T, Object> entry : fieldMap.getOverflowEntries()) {
- replaceBuilders(entry);
+ replaceBuilders(entry, partial);
 }
 }
 
 private static <T extends FieldDescriptorLite<T>> void replaceBuilders(
- Map.Entry<T, Object> entry) {
- entry.setValue(replaceBuilders(entry.getKey(), entry.getValue()));
+ Map.Entry<T, Object> entry, boolean partial) {
+ entry.setValue(replaceBuilders(entry.getKey(), entry.getValue(), partial));
 }
 
 private static <T extends FieldDescriptorLite<T>> Object replaceBuilders(
- T descriptor, Object value) {
+ T descriptor, Object value, boolean partial) {
 if (value == null) {
 return value;
 }
@@ -981,7 +1007,7 @@ final class FieldSet<T extends FieldSet.FieldDescriptorLite<T>> {
 List<Object> list = (List<Object>) value;
 for (int i = 0; i < list.size(); i++) {
 Object oldElement = list.get(i);
- Object newElement = replaceBuilder(oldElement);
+ Object newElement = replaceBuilder(oldElement, partial);
 if (newElement != oldElement) {
 // If the list contains a Message.Builder, then make a copy of that list and then
 // modify the Message.Builder into a Message and return the new list. This way, the
@@ -995,14 +1021,21 @@ final class FieldSet<T extends FieldSet.FieldDescriptorLite<T>> {
 }
 return list;
 } else {
- return replaceBuilder(value);
+ return replaceBuilder(value, partial);
 }
 }
 return value;
 }
 
- private static Object replaceBuilder(Object value) {
- return (value instanceof MessageLite.Builder) ? ((MessageLite.Builder) value).build() : value;
+ private static Object replaceBuilder(Object value, boolean partial) {
+ if (!(value instanceof MessageLite.Builder)) {
+ return value;
+ }
+ MessageLite.Builder builder = (MessageLite.Builder) value;
+ if (partial) {
+ return builder.buildPartial();
+ }
+ return builder.build();
 }
 
 /** Returns a new Builder using the fields from {@code fieldSet}. */
@@ -1021,7 +1054,7 @@ final class FieldSet<T extends FieldSet.FieldDescriptorLite<T>> {
 if (fields.isImmutable()) {
 result.makeImmutable();
 } else {
- replaceBuilders(result);
+ replaceBuilders(result, true);
 }
 return result;
 }
@@ -1044,7 +1077,7 @@ final class FieldSet<T extends FieldSet.FieldDescriptorLite<T>> {
 */
 public Object getField(final T descriptor) {
 Object value = getFieldAllowBuilders(descriptor);
- return replaceBuilders(descriptor, value);
+ return replaceBuilders(descriptor, value, true);
 }
 
 /** Same as {@link #getField(F)}, but allow a {@link MessageLite.Builder} to be returned. */
@@ -1131,7 +1164,7 @@ final class FieldSet<T extends FieldSet.FieldDescriptorLite<T>> {
 ensureIsMutable();
 }
 Object value = getRepeatedFieldAllowBuilders(descriptor, index);
- return replaceBuilder(value);
+ return replaceBuilder(value, true);
 }
 
 /**
diff --git a/java/core/src/main/java/com/google/protobuf/GeneratedMessageLite.java b/java/core/src/main/java/com/google/protobuf/GeneratedMessageLite.java
index 27f5210..943f6ee 100644
--- a/java/core/src/main/java/com/google/protobuf/GeneratedMessageLite.java
+++ b/java/core/src/main/java/com/google/protobuf/GeneratedMessageLite.java
@@ -62,11 +62,50 @@ public abstract class GeneratedMessageLite<
 BuilderType extends GeneratedMessageLite.Builder<MessageType, BuilderType>>
 extends AbstractMessageLite<MessageType, BuilderType> {
 
+ /* For use by lite runtime only */
+ static final int UNINITIALIZED_SERIALIZED_SIZE = 0x7FFFFFFF;
+ private static final int MUTABLE_FLAG_MASK = 0x80000000;
+ private static final int MEMOIZED_SERIALIZED_SIZE_MASK = 0x7FFFFFFF;
+
+ /**
+ * We use the high bit of memoizedSerializedSize as the explicit mutability flag. It didn't make
+ * sense to have negative sizes anyway. Messages start as mutable.
+ *
+ * Adding a standalone boolean would have added 8 bytes to every message instance.
+ *
+ * We also reserve 0x7FFFFFFF as the "uninitialized" value.
+ */
+ private int memoizedSerializedSize = MUTABLE_FLAG_MASK | UNINITIALIZED_SERIALIZED_SIZE;
+
+ /* For use by the runtime only */
+ static final int UNINITIALIZED_HASH_CODE = 0;
+
 /** For use by generated code only. Lazily initialized to reduce allocations. */
 protected UnknownFieldSetLite unknownFields = UnknownFieldSetLite.getDefaultInstance();
 
- /** For use by generated code only. */
- protected int memoizedSerializedSize = -1;
+ boolean isMutable() {
+ return (memoizedSerializedSize & MUTABLE_FLAG_MASK) != 0;
+ }
+
+ void markImmutable() {
+ memoizedSerializedSize &= ~MUTABLE_FLAG_MASK;
+ }
+
+ int getMemoizedHashCode() {
+ return memoizedHashCode;
+ }
+
+ void setMemoizedHashCode(int value) {
+ memoizedHashCode = value;
+ }
+
+ void clearMemoizedHashCode() {
+ memoizedHashCode = UNINITIALIZED_HASH_CODE;
+ }
+
+ boolean hashCodeIsNotMemoized() {
+ return UNINITIALIZED_HASH_CODE == getMemoizedHashCode();
+ }
 
 @Override
 @SuppressWarnings("unchecked") // Guaranteed by runtime.
@@ -86,6 +125,10 @@ public abstract class GeneratedMessageLite<
 return (BuilderType) dynamicMethod(MethodToInvoke.NEW_BUILDER);
 }
 
+ MessageType newMutableInstance() {
+ return (MessageType) dynamicMethod(MethodToInvoke.NEW_MUTABLE_INSTANCE);
+ }
+
 /**
 * A reflective toString function. This is primarily intended as a developer aid, while keeping
 * binary size down. The first line of the {@code toString()} representation includes a commented
@@ -106,11 +149,19 @@ public abstract class GeneratedMessageLite<
 @SuppressWarnings("unchecked") // Guaranteed by runtime
 @Override
 public int hashCode() {
- if (memoizedHashCode != 0) {
- return memoizedHashCode;
+ if (isMutable()) {
+ return computeHashCode();
 }
- memoizedHashCode = Protobuf.getInstance().schemaFor(this).hashCode(this);
- return memoizedHashCode;
+
+ if (hashCodeIsNotMemoized()) {
+ setMemoizedHashCode(computeHashCode());
+ }
+
+ return getMemoizedHashCode();
+ }
+
+ int computeHashCode() {
+ return Protobuf.getInstance().schemaFor(this).hashCode(this);
 }
 
 @SuppressWarnings("unchecked") // Guaranteed by isInstance + runtime
@@ -173,6 +224,7 @@ public abstract class GeneratedMessageLite<
 /** Called by subclasses to complete parsing. For use by generated code only. */
 protected void makeImmutable() {
 Protobuf.getInstance().schemaFor(this).makeImmutable(this);
+ markImmutable();
 }
 
 protected final <
@@ -198,8 +250,7 @@ public abstract class GeneratedMessageLite<
 @SuppressWarnings("unchecked")
 public final BuilderType toBuilder() {
 BuilderType builder = (BuilderType) dynamicMethod(MethodToInvoke.NEW_BUILDER);
- builder.mergeFrom((MessageType) this);
- return builder;
+ return builder.mergeFrom((MessageType) this);
 }
 
 /**
@@ -256,27 +307,67 @@ public abstract class GeneratedMessageLite<
 return dynamicMethod(method, null, null);
 }
 
+ void clearMemoizedSerializedSize() {
+ setMemoizedSerializedSize(UNINITIALIZED_SERIALIZED_SIZE);
+ }
+
 @Override
 int getMemoizedSerializedSize() {
- return memoizedSerializedSize;
+ return memoizedSerializedSize & MEMOIZED_SERIALIZED_SIZE_MASK;
 }
 
 @Override
 void setMemoizedSerializedSize(int size) {
- memoizedSerializedSize = size;
+ if (size < 0) {
+ throw new IllegalStateException("serialized size must be non-negative, was " + size);
+ }
+ memoizedSerializedSize =
+ (memoizedSerializedSize & MUTABLE_FLAG_MASK) | (size & MEMOIZED_SERIALIZED_SIZE_MASK);
 }
 
+ @Override
 public void writeTo(CodedOutputStream output) throws IOException {
 Protobuf.getInstance()
 .schemaFor(this)
 .writeTo(this, CodedOutputStreamWriter.forCodedOutput(output));
 }
 
+ @Override
+ int getSerializedSize(Schema schema) {
+ if (isMutable()) {
+ // The serialized size should never be memoized for mutable instances.
+ int size = computeSerializedSize(schema);
+ if (size < 0) {
+ throw new IllegalStateException("serialized size must be non-negative, was " + size);
+ }
+ return size;
+ }
+
+ // If memoizedSerializedSize has already been set, return it.
+ if (getMemoizedSerializedSize() != UNINITIALIZED_SERIALIZED_SIZE) {
+ return getMemoizedSerializedSize();
+ }
+
+ // Need to compute and memoize the serialized size.
+ int size = computeSerializedSize(schema);
+ setMemoizedSerializedSize(size);
+ return size;
+ }
+
+ @Override
 public int getSerializedSize() {
- if (memoizedSerializedSize == -1) {
- memoizedSerializedSize = Protobuf.getInstance().schemaFor(this).getSerializedSize(this);
+ // Calling this with 'null' to delay schema lookup in case the serializedSize is already
+ // memoized.
+ return getSerializedSize(null);
 }
- return memoizedSerializedSize;
+
+ private int computeSerializedSize(Schema<?> nullableSchema) {
+ if (nullableSchema == null) {
+ return Protobuf.getInstance().schemaFor(this).getSerializedSize(this);
+ } else {
+ return ((Schema<GeneratedMessageLite<MessageType, BuilderType>>) nullableSchema)
+ .getSerializedSize(this);
+ }
 }
 
 /** Constructs a {@link MessageInfo} for this message type. */
@@ -316,6 +407,7 @@ public abstract class GeneratedMessageLite<
 protected static <T extends GeneratedMessageLite<?, ?>> void registerDefaultInstance(
 Class<T> clazz, T defaultInstance) {
 defaultInstanceMap.put(clazz, defaultInstance);
+ defaultInstance.makeImmutable();
 }
 
 protected static Object newMessageInfo(
@@ -340,13 +432,19 @@ public abstract class GeneratedMessageLite<
 
 private final MessageType defaultInstance;
 protected MessageType instance;
- protected boolean isBuilt;
 
 protected Builder(MessageType defaultInstance) {
 this.defaultInstance = defaultInstance;
- this.instance =
- (MessageType) defaultInstance.dynamicMethod(MethodToInvoke.NEW_MUTABLE_INSTANCE);
- isBuilt = false;
+ if (defaultInstance.isMutable()) {
+ throw new IllegalArgumentException("Default instance must be immutable.");
+ }
+ // this.instance should be set to defaultInstance but some tests rely on newBuilder().build()
+ // creating unique instances.
+ this.instance = newMutableInstance();
+ }
+
+ private MessageType newMutableInstance() {
+ return defaultInstance.newMutableInstance();
 }
 
 /**
@@ -354,15 +452,13 @@ public abstract class GeneratedMessageLite<
 * state before the write happens to preserve immutability guarantees.
 */
 protected final void copyOnWrite() {
- if (isBuilt) {
+ if (!instance.isMutable()) {
 copyOnWriteInternal();
- isBuilt = false;
 }
 }
 
 protected void copyOnWriteInternal() {
- MessageType newInstance =
- (MessageType) instance.dynamicMethod(MethodToInvoke.NEW_MUTABLE_INSTANCE);
+ MessageType newInstance = newMutableInstance();
 mergeFromInstance(newInstance, instance);
 instance = newInstance;
 }
@@ -374,27 +470,28 @@ public abstract class GeneratedMessageLite<
 
 @Override
 public final BuilderType clear() {
- // No need to copy on write since we're dropping the instance anyways.
- instance = (MessageType) instance.dynamicMethod(MethodToInvoke.NEW_MUTABLE_INSTANCE);
+ // No need to copy on write since we're dropping the instance anyway.
+ if (defaultInstance.isMutable()) {
+ throw new IllegalArgumentException("Default instance must be immutable.");
+ }
+ instance = newMutableInstance(); // should be defaultInstance;
 return (BuilderType) this;
 }
 
 @Override
 public BuilderType clone() {
 BuilderType builder = (BuilderType) getDefaultInstanceForType().newBuilderForType();
- builder.mergeFrom(buildPartial());
+ builder.instance = buildPartial();
 return builder;
 }
 
 @Override
 public MessageType buildPartial() {
- if (isBuilt) {
+ if (!instance.isMutable()) {
 return instance;
 }
 
 instance.makeImmutable();
-
- isBuilt = true;
 return instance;
 }
 
@@ -414,12 +511,15 @@ public abstract class GeneratedMessageLite<
 
 /** All subclasses implement this. */
 public BuilderType mergeFrom(MessageType message) {
+ if (getDefaultInstanceForType().equals(message)) {
+ return (BuilderType) this;
+ }
 copyOnWrite();
 mergeFromInstance(instance, message);
 return (BuilderType) this;
 }
 
- private void mergeFromInstance(MessageType dest, MessageType src) {
+ private static <MessageType> void mergeFromInstance(MessageType dest, MessageType src) {
 Protobuf.getInstance().schemaFor(dest).mergeFrom(dest, src);
 }
 
@@ -930,7 +1030,9 @@ public abstract class GeneratedMessageLite<
 @Override
 protected void copyOnWriteInternal() {
 super.copyOnWriteInternal();
- instance.extensions = instance.extensions.clone();
+ if (instance.extensions != FieldSet.emptySet()) {
+ instance.extensions = instance.extensions.clone();
+ }
 }
 
 private FieldSet<ExtensionDescriptor> ensureExtensionsAreMutable() {
@@ -944,7 +1046,7 @@ public abstract class GeneratedMessageLite<
 
 @Override
 public final MessageType buildPartial() {
- if (isBuilt) {
+ if (!instance.isMutable()) {
 return instance;
 }
 
@@ -1528,7 +1630,7 @@ public abstract class GeneratedMessageLite<
 T instance, CodedInputStream input, ExtensionRegistryLite extensionRegistry)
 throws InvalidProtocolBufferException {
 @SuppressWarnings("unchecked") // Guaranteed by protoc
- T result = (T) instance.dynamicMethod(MethodToInvoke.NEW_MUTABLE_INSTANCE);
+ T result = instance.newMutableInstance();
 try {
 // TODO(yilunchong): Try to make input with type CodedInpuStream.ArrayDecoder use
 // fast path.
@@ -1554,15 +1656,12 @@ public abstract class GeneratedMessageLite<
 T instance, byte[] input, int offset, int length, ExtensionRegistryLite extensionRegistry)
 throws InvalidProtocolBufferException {
 @SuppressWarnings("unchecked") // Guaranteed by protoc
- T result = (T) instance.dynamicMethod(MethodToInvoke.NEW_MUTABLE_INSTANCE);
+ T result = instance.newMutableInstance();
 try {
 Schema<T> schema = Protobuf.getInstance().schemaFor(result);
 schema.mergeFrom(
 result, input, offset, offset + length, new ArrayDecoders.Registers(extensionRegistry));
 schema.makeImmutable(result);
- if (result.memoizedHashCode != 0) {
- throw new RuntimeException();
- }
 } catch (IOException e) {
 if (e.getCause() instanceof InvalidProtocolBufferException) {
 throw (InvalidProtocolBufferException) e.getCause();
diff --git a/java/core/src/main/java/com/google/protobuf/GeneratedMessageV3.java b/java/core/src/main/java/com/google/protobuf/GeneratedMessageV3.java
index 86f88a0..e322604 100644
--- a/java/core/src/main/java/com/google/protobuf/GeneratedMessageV3.java
+++ b/java/core/src/main/java/com/google/protobuf/GeneratedMessageV3.java
@@ -133,6 +133,10 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 return internalGetFieldAccessorTable().descriptor;
 }
 
+ // TODO(b/248143958): This method should be removed. It enables parsing directly into an
+ // "immutable" message. Have to leave it for now to support old gencode.
+ // @deprecated use newBuilder().mergeFrom() instead
+ @Deprecated
 protected void mergeFromAndMakeImmutableInternal(
 CodedInputStream input, ExtensionRegistryLite extensionRegistry)
 throws InvalidProtocolBufferException {
@@ -299,13 +303,14 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 
 @Override
 public UnknownFieldSet getUnknownFields() {
- throw new UnsupportedOperationException(
- "This is supposed to be overridden by subclasses.");
+ return unknownFields;
 }
 
 /**
 * Called by subclasses to parse an unknown field.
 *
+ * TODO(b/248153893) remove this method
+ *
 * @return {@code true} unless the tag is an end-group tag.
 */
 protected boolean parseUnknownField(
@@ -323,6 +328,8 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 /**
 * Delegates to parseUnknownField. This method is obsolete, but we must retain it for
 * compatibility with older generated code.
+ *
+ * TODO(b/248153893) remove this method
 */
 protected boolean parseUnknownFieldProto3(
 CodedInputStream input,
@@ -547,8 +554,18 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 // to dispatch dirty invalidations. See GeneratedMessageV3.BuilderListener.
 private boolean isClean;
 
- private UnknownFieldSet unknownFields =
- UnknownFieldSet.getDefaultInstance();
+ /**
+ * This field holds either an {@link UnknownFieldSet} or {@link UnknownFieldSet.Builder}.
+ *
+ * We use an object because it should only be one or the other of those things at a time and
+ * Object is the only common base. This also saves space.
+ *
+ * Conversions are lazy: if {@link #setUnknownFields} is called, this will contain {@link
+ * UnknownFieldSet}. If unknown fields are merged into this builder, the current {@link
+ * UnknownFieldSet} will be converted to a {@link UnknownFieldSet.Builder} and left that way
+ * until either {@link #setUnknownFields} or {@link #buildPartial} or {@link #build} is called.
+ */
+ private Object unknownFieldsOrBuilder = UnknownFieldSet.getDefaultInstance();
 
 protected Builder() {
 this(null);
@@ -604,7 +621,7 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 */
 @Override
 public BuilderType clear() {
- unknownFields = UnknownFieldSet.getDefaultInstance();
+ unknownFieldsOrBuilder = UnknownFieldSet.getDefaultInstance();
 onChanged();
 return (BuilderType) this;
 }
@@ -757,7 +774,7 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 }
 
 private BuilderType setUnknownFieldsInternal(final UnknownFieldSet unknownFields) {
- this.unknownFields = unknownFields;
+ unknownFieldsOrBuilder = unknownFields;
 onChanged();
 return (BuilderType) this;
 }
@@ -776,12 +793,20 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 }
 
 @Override
- public BuilderType mergeUnknownFields(
- final UnknownFieldSet unknownFields) {
- return setUnknownFields(
- UnknownFieldSet.newBuilder(this.unknownFields)
- .mergeFrom(unknownFields)
- .build());
+ public BuilderType mergeUnknownFields(final UnknownFieldSet unknownFields) {
+ if (UnknownFieldSet.getDefaultInstance().equals(unknownFields)) {
+ return (BuilderType) this;
+ }
+
+ if (UnknownFieldSet.getDefaultInstance().equals(unknownFieldsOrBuilder)) {
+ unknownFieldsOrBuilder = unknownFields;
+ onChanged();
+ return (BuilderType) this;
+ }
+
+ getUnknownFieldSetBuilder().mergeFrom(unknownFields);
+ onChanged();
+ return (BuilderType) this;
 }
 
 
@@ -817,7 +842,50 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 
 @Override
 public final UnknownFieldSet getUnknownFields() {
- return unknownFields;
+ if (unknownFieldsOrBuilder instanceof UnknownFieldSet) {
+ return (UnknownFieldSet) unknownFieldsOrBuilder;
+ } else {
+ return ((UnknownFieldSet.Builder) unknownFieldsOrBuilder).buildPartial();
+ }
+ }
+
+ /**
+ * Called by generated subclasses to parse an unknown field.
+ *
+ * @return {@code true} unless the tag is an end-group tag.
+ */
+ protected boolean parseUnknownField(
+ CodedInputStream input, ExtensionRegistryLite extensionRegistry, int tag)
+ throws IOException {
+ if (input.shouldDiscardUnknownFields()) {
+ return input.skipField(tag);
+ }
+ return getUnknownFieldSetBuilder().mergeFieldFrom(tag, input);
+ }
+
+ /** Called by generated subclasses to add to the unknown field set. */
+ protected final void mergeUnknownLengthDelimitedField(int number, ByteString bytes) {
+ getUnknownFieldSetBuilder().mergeLengthDelimitedField(number, bytes);
+ }
+
+ /** Called by generated subclasses to add to the unknown field set. */
+ protected final void mergeUnknownVarintField(int number, int value) {
+ getUnknownFieldSetBuilder().mergeVarintField(number, value);
+ }
+
+ @Override
+ protected UnknownFieldSet.Builder getUnknownFieldSetBuilder() {
+ if (unknownFieldsOrBuilder instanceof UnknownFieldSet) {
+ unknownFieldsOrBuilder = ((UnknownFieldSet) unknownFieldsOrBuilder).toBuilder();
+ }
+ onChanged();
+ return (UnknownFieldSet.Builder) unknownFieldsOrBuilder;
+ }
+
+ @Override
+ protected void setUnknownFieldSetBuilder(UnknownFieldSet.Builder builder) {
+ unknownFieldsOrBuilder = builder;
+ onChanged();
 }
 
 /**
@@ -1609,7 +1677,7 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 private FieldSet<FieldDescriptor> buildExtensions() {
 return extensions == null
 ? (FieldSet<FieldDescriptor>) FieldSet.emptySet()
- : extensions.build();
+ : extensions.buildPartial();
 }
 
 @Override
@@ -1815,6 +1883,20 @@ public abstract class GeneratedMessageV3 extends AbstractMessage
 }
 }
 
+ @Override
+ protected boolean parseUnknownField(
+ CodedInputStream input, ExtensionRegistryLite extensionRegistry, int tag)
+ throws IOException {
+ ensureExtensionsIsMutable();
+ return MessageReflection.mergeFieldFrom(
+ input,
+ input.shouldDiscardUnknownFields() ? null : getUnknownFieldSetBuilder(),
+ extensionRegistry,
+ getDescriptorForType(),
+ new MessageReflection.ExtensionBuilderAdapter(extensions),
+ tag);
+ }
+
 private void verifyContainingType(final FieldDescriptor field) {
 if (field.getContainingType() != getDescriptorForType()) {
 throw new IllegalArgumentException(
diff --git a/java/core/src/main/java/com/google/protobuf/MessageLiteToString.java b/java/core/src/main/java/com/google/protobuf/MessageLiteToString.java
index 4aea952..3a3a70f 100644
--- a/java/core/src/main/java/com/google/protobuf/MessageLiteToString.java
+++ b/java/core/src/main/java/com/google/protobuf/MessageLiteToString.java
@@ -32,12 +32,15 @@ package com.google.protobuf;
 
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
-import java.util.TreeSet;
+import java.util.TreeMap;
 
 /** Helps generate {@link String} representations of {@link MessageLite} protos. */
 final class MessageLiteToString {
@@ -46,6 +49,11 @@ final class MessageLiteToString {
 private static final String BUILDER_LIST_SUFFIX = "OrBuilderList";
 private static final String MAP_SUFFIX = "Map";
 private static final String BYTES_SUFFIX = "Bytes";
+ private static final char[] INDENT_BUFFER = new char[80];
+
+ static {
+ Arrays.fill(INDENT_BUFFER, ' ');
+ }
 
 /**
 * Returns a {@link String} representation of the {@link MessageLite} object. The first line of
@@ -73,37 +81,51 @@ final class MessageLiteToString {
 // Build a map of method name to method. We're looking for methods like getFoo(), hasFoo(),
 // getFooList() and getFooMap() which might be useful for building an object's string
 // representation.
- Map<String, Method> nameToNoArgMethod = new HashMap<String, Method>();
- Map<String, Method> nameToMethod = new HashMap<String, Method>();
- Set<String> getters = new TreeSet<String>();
+ Set<String> setters = new HashSet<>();
+ Map<String, Method> hazzers = new HashMap<>();
+ Map<String, Method> getters = new TreeMap<>();
 for (Method method : messageLite.getClass().getDeclaredMethods()) {
- nameToMethod.put(method.getName(), method);
- if (method.getParameterTypes().length == 0) {
- nameToNoArgMethod.put(method.getName(), method);
+ if (Modifier.isStatic(method.getModifiers())) {
+ continue;
+ }
+ if (method.getName().length() < 3) {
+ continue;
+ }
 
- if (method.getName().startsWith("get")) {
- getters.add(method.getName());
- }
+ if (method.getName().startsWith("set")) {
+ setters.add(method.getName());
+ continue;
+ }
+
+ if (!Modifier.isPublic(method.getModifiers())) {
+ continue;
+ }
+
+ if (method.getParameterTypes().length != 0) {
+ continue;
+ }
+
+ if (method.getName().startsWith("has")) {
+ hazzers.put(method.getName(), method);
+ } else if (method.getName().startsWith("get")) {
+ getters.put(method.getName(), method);
 }
 }
 
- for (String getter : getters) {
- String suffix = getter.startsWith("get") ? getter.substring(3) : getter;
+ for (Entry<String, Method> getter : getters.entrySet()) {
+ String suffix = getter.getKey().substring(3);
 if (suffix.endsWith(LIST_SUFFIX)
 && !suffix.endsWith(BUILDER_LIST_SUFFIX)
 // Sometimes people have fields named 'list' that aren't repeated.
 && !suffix.equals(LIST_SUFFIX)) {
- String camelCase =
- suffix.substring(0, 1).toLowerCase()
- + suffix.substring(1, suffix.length() - LIST_SUFFIX.length());
 // Try to reflectively get the value and toString() the field as if it were repeated. This
 // only works if the method names have not been proguarded out or renamed.
- Method listMethod = nameToNoArgMethod.get(getter);
+ Method listMethod = getter.getValue();
 if (listMethod != null && listMethod.getReturnType().equals(List.class)) {
 printField(
 buffer,
 indent,
- camelCaseToSnakeCase(camelCase),
+ suffix.substring(0, suffix.length() - LIST_SUFFIX.length()),
 GeneratedMessageLite.invokeOrDie(listMethod, messageLite));
 continue;
 }
@@ -111,12 +133,9 @@ final class MessageLiteToString {
 if (suffix.endsWith(MAP_SUFFIX)
 // Sometimes people have fields named 'map' that aren't maps.
 && !suffix.equals(MAP_SUFFIX)) {
- String camelCase =
- suffix.substring(0, 1).toLowerCase()
- + suffix.substring(1, suffix.length() - MAP_SUFFIX.length());
 // Try to reflectively get the value and toString() the field as if it were a map. This only
 // works if the method names have not been proguarded out or renamed.
- Method mapMethod = nameToNoArgMethod.get(getter);
+ Method mapMethod = getter.getValue();
 if (mapMethod != null
 && mapMethod.getReturnType().equals(Map.class)
 // Skip the deprecated getter method with no prefix "Map" when the field name ends with
@@ -127,29 +146,25 @@ final class MessageLiteToString {
 printField(
 buffer,
 indent,
- camelCaseToSnakeCase(camelCase),
+ suffix.substring(0, suffix.length() - MAP_SUFFIX.length()),
 GeneratedMessageLite.invokeOrDie(mapMethod, messageLite));
 continue;
 }
 }
 
- Method setter = nameToMethod.get("set" + suffix);
- if (setter == null) {
+ if (!setters.contains("set" + suffix)) {
 continue;
 }
 if (suffix.endsWith(BYTES_SUFFIX)
- && nameToNoArgMethod.containsKey(
- "get" + suffix.substring(0, suffix.length() - "Bytes".length()))) {
+ && getters.containsKey("get" + suffix.substring(0, suffix.length() - "Bytes".length()))) {
 // Heuristic to skip bytes based accessors for string fields.
 continue;
 }
 
- String camelCase = suffix.substring(0, 1).toLowerCase() + suffix.substring(1);
-
 // Try to reflectively get the value and toString() the field as if it were optional. This
 // only works if the method names have not been proguarded out or renamed.
- Method getMethod = nameToNoArgMethod.get("get" + suffix);
- Method hasMethod = nameToNoArgMethod.get("has" + suffix);
+ Method getMethod = getter.getValue();
+ Method hasMethod = hazzers.get("has" + suffix);
 // TODO(dweis): Fix proto3 semantics.
 if (getMethod != null) {
 Object value = GeneratedMessageLite.invokeOrDie(getMethod, messageLite);
@@ -159,7 +174,7 @@ final class MessageLiteToString {
 : (Boolean) GeneratedMessageLite.invokeOrDie(hasMethod, messageLite);
 // TODO(dweis): This doesn't stop printing oneof case twice: value and enum style.
 if (hasValue) {
- printField(buffer, indent, camelCaseToSnakeCase(camelCase), value);
+ printField(buffer, indent, suffix, value);
 }
 continue;
 }
@@ -215,10 +230,10 @@ final class MessageLiteToString {
 *
 * @param buffer the buffer to write to
 * @param indent the number of spaces the proto should be indented by
- * @param name the field name (in lower underscore case)
+ * @param name the field name (in PascalCase)
 * @param object the object value of the field
 */
- static final void printField(StringBuilder buffer, int indent, String name, Object object) {
+ static void printField(StringBuilder buffer, int indent, String name, Object object) {
 if (object instanceof List<?>) {
 List<?> list = (List<?>) object;
 for (Object entry : list) {
@@ -235,10 +250,8 @@ final class MessageLiteToString {
 }
 
 buffer.append('\n');
- for (int i = 0; i < indent; i++) {
- buffer.append(' ');
- }
- buffer.append(name);
+ indent(indent, buffer);
+ buffer.append(pascalCaseToSnakeCase(name));
 
 if (object instanceof String) {
 buffer.append(": \"").append(TextFormatEscaper.escapeText((String) object)).append('"');
@@ -248,9 +261,7 @@ final class MessageLiteToString {
 buffer.append(" {");
 reflectivePrintWithIndent((GeneratedMessageLite<?, ?>) object, buffer, indent + 2);
 buffer.append("\n");
- for (int i = 0; i < indent; i++) {
- buffer.append(' ');
- }
+ indent(indent, buffer);
 buffer.append("}");
 } else if (object instanceof Map.Entry<?, ?>) {
 buffer.append(" {");
@@ -258,19 +269,33 @@ final class MessageLiteToString {
 printField(buffer, indent + 2, "key", entry.getKey());
 printField(buffer, indent + 2, "value", entry.getValue());
 buffer.append("\n");
- for (int i = 0; i < indent; i++) {
- buffer.append(' ');
- }
+ indent(indent, buffer);
 buffer.append("}");
 } else {
 buffer.append(": ").append(object.toString());
 }
 }
 
- private static final String camelCaseToSnakeCase(String camelCase) {
+ private static void indent(int indent, StringBuilder buffer) {
+ while (indent > 0) {
+ int partialIndent = indent;
+ if (partialIndent > INDENT_BUFFER.length) {
+ partialIndent = INDENT_BUFFER.length;
+ }
+ buffer.append(INDENT_BUFFER, 0, partialIndent);
+ indent -= partialIndent;
+ }
+ }
+
+ private static String pascalCaseToSnakeCase(String pascalCase) {
+ if (pascalCase.isEmpty()) {
+ return pascalCase;
+ }
+
 StringBuilder builder = new StringBuilder();
- for (int i = 0; i < camelCase.length(); i++) {
- char ch = camelCase.charAt(i);
+ builder.append(Character.toLowerCase(pascalCase.charAt(0)));
+ for (int i = 1; i < pascalCase.length(); i++) {
+ char ch = pascalCase.charAt(i);
 if (Character.isUpperCase(ch)) {
 builder.append("_");
 }
diff --git a/java/core/src/main/java/com/google/protobuf/MessageReflection.java b/java/core/src/main/java/com/google/protobuf/MessageReflection.java
index 6741e1c..13a6b8d 100644
--- a/java/core/src/main/java/com/google/protobuf/MessageReflection.java
+++ b/java/core/src/main/java/com/google/protobuf/MessageReflection.java
@@ -30,6 +30,7 @@
 
 package com.google.protobuf;
 
+import com.google.protobuf.Descriptors.Descriptor;
 import com.google.protobuf.Descriptors.FieldDescriptor;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -323,6 +324,34 @@ class MessageReflection {
 Message defaultInstance)
 throws IOException;
 
+ /**
+ * Read the given group field from the wire, merging with the existing field if it is already
+ * present.
+ *
+ * For extensions, defaultInstance must be specified. For regular fields, defaultInstance can
+ * be null.
+ */
+ void mergeGroup(
+ CodedInputStream input,
+ ExtensionRegistryLite extensionRegistry,
+ FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException;
+
+ /**
+ * Read the given message field from the wire, merging with the existing field if it is already
+ * present.
+ *
+ * For extensions, defaultInstance must be specified. For regular fields, defaultInstance can
+ * be null.
+ */
+ void mergeMessage(
+ CodedInputStream input,
+ ExtensionRegistryLite extensionRegistry,
+ FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException;
+
 /** Returns the UTF8 validation level for the field. */
 WireFormat.Utf8Validation getUtf8Validation(Descriptors.FieldDescriptor descriptor);
 
@@ -349,6 +378,7 @@ class MessageReflection {
 static class BuilderAdapter implements MergeTarget {
 
 private final Message.Builder builder;
+ private boolean hasNestedBuilders = true;
 
 @Override
 public Descriptors.Descriptor getDescriptorForType() {
@@ -364,6 +394,17 @@ class MessageReflection {
 return builder.getField(field);
 }
 
+ private Message.Builder getFieldBuilder(Descriptors.FieldDescriptor field) {
+ if (hasNestedBuilders) {
+ try {
+ return builder.getFieldBuilder(field);
+ } catch (UnsupportedOperationException e) {
+ hasNestedBuilders = false;
+ }
+ }
+ return null;
+ }
+
 @Override
 public boolean hasField(Descriptors.FieldDescriptor field) {
 return builder.hasField(field);
@@ -371,6 +412,12 @@ class MessageReflection {
 
 @Override
 public MergeTarget setField(Descriptors.FieldDescriptor field, Object value) {
+ if (!field.isRepeated() && value instanceof MessageLite.Builder) {
+ if (value != getFieldBuilder(field)) {
+ builder.setField(field, ((MessageLite.Builder) value).buildPartial());
+ }
+ return this;
+ }
 builder.setField(field, value);
 return this;
 }
@@ -384,12 +431,18 @@ class MessageReflection {
 @Override
 public MergeTarget setRepeatedField(
 Descriptors.FieldDescriptor field, int index, Object value) {
+ if (value instanceof MessageLite.Builder) {
+ value = ((MessageLite.Builder) value).buildPartial();
+ }
 builder.setRepeatedField(field, index, value);
 return this;
 }
 
 @Override
 public MergeTarget addRepeatedField(Descriptors.FieldDescriptor field, Object value) {
+ if (value instanceof MessageLite.Builder) {
+ value = ((MessageLite.Builder) value).buildPartial();
+ }
 builder.addRepeatedField(field, value);
 return this;
 }
@@ -499,15 +552,88 @@ class MessageReflection {
 return subBuilder.buildPartial();
 }
 
+ @Override
+ public void mergeGroup(
+ CodedInputStream input,
+ ExtensionRegistryLite extensionRegistry,
+ FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException {
+ if (!field.isRepeated()) {
+ Message.Builder subBuilder;
+ if (hasField(field)) {
+ subBuilder = getFieldBuilder(field);
+ if (subBuilder != null) {
+ input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
+ return;
+ } else {
+ subBuilder = newMessageFieldInstance(field, defaultInstance);
+ subBuilder.mergeFrom((Message) getField(field));
+ }
+ } else {
+ subBuilder = newMessageFieldInstance(field, defaultInstance);
+ }
+ input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
+ Object unused = setField(field, subBuilder.buildPartial());
+ } else {
+ Message.Builder subBuilder = newMessageFieldInstance(field, defaultInstance);
+ input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
+ Object unused = addRepeatedField(field, subBuilder.buildPartial());
+ }
+ }
+
+ @Override
+ public void mergeMessage(
+ CodedInputStream input,
+ ExtensionRegistryLite extensionRegistry,
+ Descriptors.FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException {
+ if (!field.isRepeated()) {
+ Message.Builder subBuilder;
+ if (hasField(field)) {
+ subBuilder = getFieldBuilder(field);
+ if (subBuilder != null) {
+ input.readMessage(subBuilder, extensionRegistry);
+ return;
+ } else {
+ subBuilder = newMessageFieldInstance(field, defaultInstance);
+ subBuilder.mergeFrom((Message) getField(field));
+ }
+ } else {
+ subBuilder = newMessageFieldInstance(field, defaultInstance);
+ }
+ input.readMessage(subBuilder, extensionRegistry);
+ Object unused = setField(field, subBuilder.buildPartial());
+ } else {
+ Message.Builder subBuilder = newMessageFieldInstance(field, defaultInstance);
+ input.readMessage(subBuilder, extensionRegistry);
+ Object unused = addRepeatedField(field, subBuilder.buildPartial());
+ }
+ }
+
+ private Message.Builder newMessageFieldInstance(
+ FieldDescriptor field, Message defaultInstance) {
+ // When default instance is not null. The field is an extension field.
+ if (defaultInstance != null) {
+ return defaultInstance.newBuilderForType();
+ } else {
+ return builder.newBuilderForField(field);
+ }
+ }
+
 @Override
 public MergeTarget newMergeTargetForField(
 Descriptors.FieldDescriptor field, Message defaultInstance) {
 Message.Builder subBuilder;
- if (defaultInstance != null) {
- subBuilder = defaultInstance.newBuilderForType();
- } else {
- subBuilder = builder.newBuilderForField(field);
+ if (!field.isRepeated() && hasField(field)) {
+ subBuilder = getFieldBuilder(field);
+ if (subBuilder != null) {
+ return new BuilderAdapter(subBuilder);
+ }
 }
+
+ subBuilder = newMessageFieldInstance(field, defaultInstance);
 if (!field.isRepeated()) {
 Message originalMessage = (Message) getField(field);
 if (originalMessage != null) {
@@ -543,7 +669,7 @@ class MessageReflection {
 
 @Override
 public Object finish() {
- return builder.buildPartial();
+ return builder;
 }
 }
 
@@ -665,6 +791,276 @@ class MessageReflection {
 return subBuilder.buildPartial();
 }
 
+ @Override
+ public void mergeGroup(
+ CodedInputStream input,
+ ExtensionRegistryLite extensionRegistry,
+ FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException {
+ if (!field.isRepeated()) {
+ if (hasField(field)) {
+ MessageLite.Builder current = ((MessageLite) getField(field)).toBuilder();
+ input.readGroup(field.getNumber(), current, extensionRegistry);
+ Object unused = setField(field, current.buildPartial());
+ return;
+ }
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
+ Object unused = setField(field, subBuilder.buildPartial());
+ } else {
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
+ Object unused = addRepeatedField(field, subBuilder.buildPartial());
+ }
+ }
+
+ @Override
+ public void mergeMessage(
+ CodedInputStream input,
+ ExtensionRegistryLite extensionRegistry,
+ FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException {
+ if (!field.isRepeated()) {
+ if (hasField(field)) {
+ MessageLite.Builder current = ((MessageLite) getField(field)).toBuilder();
+ input.readMessage(current, extensionRegistry);
+ Object unused = setField(field, current.buildPartial());
+ return;
+ }
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ input.readMessage(subBuilder, extensionRegistry);
+ Object unused = setField(field, subBuilder.buildPartial());
+ } else {
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ input.readMessage(subBuilder, extensionRegistry);
+ Object unused = addRepeatedField(field, subBuilder.buildPartial());
+ }
+ }
+
+ @Override
+ public Object parseMessageFromBytes(
+ ByteString bytes,
+ ExtensionRegistryLite registry,
+ Descriptors.FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException {
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ if (!field.isRepeated()) {
+ Message originalMessage = (Message) getField(field);
+ if (originalMessage != null) {
+ subBuilder.mergeFrom(originalMessage);
+ }
+ }
+ subBuilder.mergeFrom(bytes, registry);
+ return subBuilder.buildPartial();
+ }
+
+ @Override
+ public MergeTarget newMergeTargetForField(
+ Descriptors.FieldDescriptor descriptor, Message defaultInstance) {
+ throw new UnsupportedOperationException("newMergeTargetForField() called on FieldSet object");
+ }
+
+ @Override
+ public MergeTarget newEmptyTargetForField(
+ Descriptors.FieldDescriptor descriptor, Message defaultInstance) {
+ throw new UnsupportedOperationException("newEmptyTargetForField() called on FieldSet object");
+ }
+
+ @Override
+ public WireFormat.Utf8Validation getUtf8Validation(Descriptors.FieldDescriptor descriptor) {
+ if (descriptor.needsUtf8Check()) {
+ return WireFormat.Utf8Validation.STRICT;
+ }
+ // TODO(b/248145492): support lazy strings for ExtesnsionSet.
+ return WireFormat.Utf8Validation.LOOSE;
+ }
+
+ @Override
+ public Object finish() {
+ throw new UnsupportedOperationException("finish() called on FieldSet object");
+ }
+ }
+
+ static class ExtensionBuilderAdapter implements MergeTarget {
+
+ private final FieldSet.Builder<Descriptors.FieldDescriptor> extensions;
+
+ ExtensionBuilderAdapter(FieldSet.Builder<Descriptors.FieldDescriptor> extensions) {
+ this.extensions = extensions;
+ }
+
+ @Override
+ public Descriptors.Descriptor getDescriptorForType() {
+ throw new UnsupportedOperationException("getDescriptorForType() called on FieldSet object");
+ }
+
+ @Override
+ public Object getField(Descriptors.FieldDescriptor field) {
+ return extensions.getField(field);
+ }
+
+ @Override
+ public boolean hasField(Descriptors.FieldDescriptor field) {
+ return extensions.hasField(field);
+ }
+
+ @Override
+ public MergeTarget setField(Descriptors.FieldDescriptor field, Object value) {
+ extensions.setField(field, value);
+ return this;
+ }
+
+ @Override
+ public MergeTarget clearField(Descriptors.FieldDescriptor field) {
+ extensions.clearField(field);
+ return this;
+ }
+
+ @Override
+ public MergeTarget setRepeatedField(
+ Descriptors.FieldDescriptor field, int index, Object value) {
+ extensions.setRepeatedField(field, index, value);
+ return this;
+ }
+
+ @Override
+ public MergeTarget addRepeatedField(Descriptors.FieldDescriptor field, Object value) {
+ extensions.addRepeatedField(field, value);
+ return this;
+ }
+
+ @Override
+ public boolean hasOneof(Descriptors.OneofDescriptor oneof) {
+ return false;
+ }
+
+ @Override
+ public MergeTarget clearOneof(Descriptors.OneofDescriptor oneof) {
+ // Nothing to clear.
+ return this;
+ }
+
+ @Override
+ public Descriptors.FieldDescriptor getOneofFieldDescriptor(Descriptors.OneofDescriptor oneof) {
+ return null;
+ }
+
+ @Override
+ public ContainerType getContainerType() {
+ return ContainerType.EXTENSION_SET;
+ }
+
+ @Override
+ public ExtensionRegistry.ExtensionInfo findExtensionByName(
+ ExtensionRegistry registry, String name) {
+ return registry.findImmutableExtensionByName(name);
+ }
+
+ @Override
+ public ExtensionRegistry.ExtensionInfo findExtensionByNumber(
+ ExtensionRegistry registry, Descriptors.Descriptor containingType, int fieldNumber) {
+ return registry.findImmutableExtensionByNumber(containingType, fieldNumber);
+ }
+
+ @Override
+ public Object parseGroup(
+ CodedInputStream input,
+ ExtensionRegistryLite registry,
+ Descriptors.FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException {
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ if (!field.isRepeated()) {
+ Message originalMessage = (Message) getField(field);
+ if (originalMessage != null) {
+ subBuilder.mergeFrom(originalMessage);
+ }
+ }
+ input.readGroup(field.getNumber(), subBuilder, registry);
+ return subBuilder.buildPartial();
+ }
+
+ @Override
+ public Object parseMessage(
+ CodedInputStream input,
+ ExtensionRegistryLite registry,
+ Descriptors.FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException {
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ if (!field.isRepeated()) {
+ Message originalMessage = (Message) getField(field);
+ if (originalMessage != null) {
+ subBuilder.mergeFrom(originalMessage);
+ }
+ }
+ input.readMessage(subBuilder, registry);
+ return subBuilder.buildPartial();
+ }
+
+ @Override
+ public void mergeGroup(
+ CodedInputStream input,
+ ExtensionRegistryLite extensionRegistry,
+ FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException {
+ if (!field.isRepeated()) {
+ if (hasField(field)) {
+ Object fieldOrBuilder = extensions.getFieldAllowBuilders(field);
+ MessageLite.Builder subBuilder;
+ if (fieldOrBuilder instanceof MessageLite.Builder) {
+ subBuilder = (MessageLite.Builder) fieldOrBuilder;
+ } else {
+ subBuilder = ((MessageLite) fieldOrBuilder).toBuilder();
+ extensions.setField(field, subBuilder);
+ }
+ input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
+ return;
+ }
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
+ Object unused = setField(field, subBuilder);
+ } else {
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
+ Object unused = addRepeatedField(field, subBuilder.buildPartial());
+ }
+ }
+
+ @Override
+ public void mergeMessage(
+ CodedInputStream input,
+ ExtensionRegistryLite extensionRegistry,
+ FieldDescriptor field,
+ Message defaultInstance)
+ throws IOException {
+ if (!field.isRepeated()) {
+ if (hasField(field)) {
+ Object fieldOrBuilder = extensions.getFieldAllowBuilders(field);
+ MessageLite.Builder subBuilder;
+ if (fieldOrBuilder instanceof MessageLite.Builder) {
+ subBuilder = (MessageLite.Builder) fieldOrBuilder;
+ } else {
+ subBuilder = ((MessageLite) fieldOrBuilder).toBuilder();
+ extensions.setField(field, subBuilder);
+ }
+ input.readMessage(subBuilder, extensionRegistry);
+ return;
+ }
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ input.readMessage(subBuilder, extensionRegistry);
+ Object unused = setField(field, subBuilder);
+ } else {
+ Message.Builder subBuilder = defaultInstance.newBuilderForType();
+ input.readMessage(subBuilder, extensionRegistry);
+ Object unused = addRepeatedField(field, subBuilder.buildPartial());
+ }
+ }
+
 @Override
 public Object parseMessageFromBytes(
 ByteString bytes,
@@ -700,7 +1096,7 @@ class MessageReflection {
 if (descriptor.needsUtf8Check()) {
 return WireFormat.Utf8Validation.STRICT;
 }
- // TODO(liujisi): support lazy strings for ExtesnsionSet.
+ // TODO(b/248145492): support lazy strings for ExtesnsionSet.
 return WireFormat.Utf8Validation.LOOSE;
 }
 
@@ -829,13 +1225,13 @@ class MessageReflection {
 switch (field.getType()) {
 case GROUP:
 {
- value = target.parseGroup(input, extensionRegistry, field, defaultInstance);
- break;
+ target.mergeGroup(input, extensionRegistry, field, defaultInstance);
+ return true;
 }
 case MESSAGE:
 {
- value = target.parseMessage(input, extensionRegistry, field, defaultInstance);
- break;
+ target.mergeMessage(input, extensionRegistry, field, defaultInstance);
+ return true;
 }
 case ENUM:
 final int rawValue = input.readEnum();
@@ -870,6 +1266,29 @@ class MessageReflection {
 return true;
 }
 
+ /** Read a message from the given input stream into the provided target and UnknownFieldSet. */
+ static void mergeMessageFrom(
+ Message.Builder target,
+ UnknownFieldSet.Builder unknownFields,
+ CodedInputStream input,
+ ExtensionRegistryLite extensionRegistry)
+ throws IOException {
+ BuilderAdapter builderAdapter = new BuilderAdapter(target);
+ Descriptor descriptorForType = target.getDescriptorForType();
+ while (true) {
+ final int tag = input.readTag();
+ if (tag == 0) {
+ break;
+ }
+
+ if (!mergeFieldFrom(
+ input, unknownFields, extensionRegistry, descriptorForType, builderAdapter, tag)) {
+ // end group tag
+ break;
+ }
+ }
+ }
+
 /** Called by {@code #mergeFieldFrom()} to parse a MessageSet extension into MergeTarget. */
 private static void mergeMessageSetExtensionFromCodedStream(
 CodedInputStream input,
diff --git a/java/core/src/main/java/com/google/protobuf/MessageSchema.java b/java/core/src/main/java/com/google/protobuf/MessageSchema.java
index 33c8e91..8f873c1 100644
--- a/java/core/src/main/java/com/google/protobuf/MessageSchema.java
+++ b/java/core/src/main/java/com/google/protobuf/MessageSchema.java
@@ -42,7 +42,6 @@ import static com.google.protobuf.ArrayDecoders.decodeFixed64;
 import static com.google.protobuf.ArrayDecoders.decodeFixed64List;
 import static com.google.protobuf.ArrayDecoders.decodeFloat;
 import static com.google.protobuf.ArrayDecoders.decodeFloatList;
-import static com.google.protobuf.ArrayDecoders.decodeGroupField;
 import static com.google.protobuf.ArrayDecoders.decodeGroupList;
 import static com.google.protobuf.ArrayDecoders.decodeMessageField;
 import static com.google.protobuf.ArrayDecoders.decodeMessageList;
@@ -66,6 +65,8 @@ import static com.google.protobuf.ArrayDecoders.decodeVarint32;
 import static com.google.protobuf.ArrayDecoders.decodeVarint32List;
 import static com.google.protobuf.ArrayDecoders.decodeVarint64;
 import static com.google.protobuf.ArrayDecoders.decodeVarint64List;
+import static com.google.protobuf.ArrayDecoders.mergeGroupField;
+import static com.google.protobuf.ArrayDecoders.mergeMessageField;
 import static com.google.protobuf.ArrayDecoders.skipField;
 
 import com.google.protobuf.ArrayDecoders.Registers;
@@ -1176,6 +1177,7 @@ final class MessageSchema<T> implements Schema<T> {
 
 @Override
 public void mergeFrom(T message, T other) {
+ checkMutable(message);
 if (other == null) {
 throw new NullPointerException();
 }
@@ -1374,47 +1376,83 @@ final class MessageSchema<T> implements Schema<T> {
 }
 }
 
- private void mergeMessage(T message, T other, int pos) {
+ private void mergeMessage(T targetParent, T sourceParent, int pos) {
+ if (!isFieldPresent(sourceParent, pos)) {
+ return;
+ }
+
 final int typeAndOffset = typeAndOffsetAt(pos);
 final long offset = offset(typeAndOffset);
 
- if (!isFieldPresent(other, pos)) {
+ final Object source = UNSAFE.getObject(sourceParent, offset);
+ if (source == null) {
+ throw new IllegalStateException(
+ "Source subfield " + numberAt(pos) + " is present but null: " + sourceParent);
+ }
+
+ final Schema fieldSchema = getMessageFieldSchema(pos);
+ if (!isFieldPresent(targetParent, pos)) {
+ if (!isMutable(source)) {
+ // Can safely share source if it is immutable
+ UNSAFE.putObject(targetParent, offset, source);
+ } else {
+ // Make a safetey copy of source
+ final Object copyOfSource = fieldSchema.newInstance();
+ fieldSchema.mergeFrom(copyOfSource, source);
+ UNSAFE.putObject(targetParent, offset, copyOfSource);
+ }
+ setFieldPresent(targetParent, pos);
 return;
 }
 
- Object mine = UnsafeUtil.getObject(message, offset);
- Object theirs = UnsafeUtil.getObject(other, offset);
- if (mine != null && theirs != null) {
- Object merged = Internal.mergeMessage(mine, theirs);
- UnsafeUtil.putObject(message, offset, merged);
- setFieldPresent(message, pos);
- } else if (theirs != null) {
- UnsafeUtil.putObject(message, offset, theirs);
- setFieldPresent(message, pos);
+ // Sub-message is present, merge from source
+ Object target = UNSAFE.getObject(targetParent, offset);
+ if (!isMutable(target)) {
+ Object newInstance = fieldSchema.newInstance();
+ fieldSchema.mergeFrom(newInstance, target);
+ UNSAFE.putObject(targetParent, offset, newInstance);
+ target = newInstance;
 }
+ fieldSchema.mergeFrom(target, source);
 }
 
- private void mergeOneofMessage(T message, T other, int pos) {
- int typeAndOffset = typeAndOffsetAt(pos);
+ private void mergeOneofMessage(T targetParent, T sourceParent, int pos) {
 int number = numberAt(pos);
- long offset = offset(typeAndOffset);
-
- if (!isOneofPresent(other, number, pos)) {
+ if (!isOneofPresent(sourceParent, number, pos)) {
 return;
 }
- Object mine = null;
- if (isOneofPresent(message, number, pos)) {
- mine = UnsafeUtil.getObject(message, offset);
+
+ long offset = offset(typeAndOffsetAt(pos));
+ final Object source = UNSAFE.getObject(sourceParent, offset);
+ if (source == null) {
+ throw new IllegalStateException(
+ "Source subfield " + numberAt(pos) + " is present but null: " + sourceParent);
 }
- Object theirs = UnsafeUtil.getObject(other, offset);
- if (mine != null && theirs != null) {
- Object merged = Internal.mergeMessage(mine, theirs);
- UnsafeUtil.putObject(message, offset, merged);
- setOneofPresent(message, number, pos);
- } else if (theirs != null) {
- UnsafeUtil.putObject(message, offset, theirs);
- setOneofPresent(message, number, pos);
+
+ final Schema fieldSchema = getMessageFieldSchema(pos);
+ if (!isOneofPresent(targetParent, number, pos)) {
+ if (!isMutable(source)) {
+ // Can safely share source if it is immutable
+ UNSAFE.putObject(targetParent, offset, source);
+ } else {
+ // Make a safety copy of theirs
+ final Object copyOfSource = fieldSchema.newInstance();
+ fieldSchema.mergeFrom(copyOfSource, source);
+ UNSAFE.putObject(targetParent, offset, copyOfSource);
+ }
+ setOneofPresent(targetParent, number, pos);
+ return;
 }
+
+ // Sub-message is present, merge from source
+ Object target = UNSAFE.getObject(targetParent, offset);
+ if (!isMutable(target)) {
+ Object newInstance = fieldSchema.newInstance();
+ fieldSchema.mergeFrom(newInstance, target);
+ UNSAFE.putObject(targetParent, offset, newInstance);
+ target = newInstance;
+ }
+ fieldSchema.mergeFrom(target, source);
 }
 
 @Override
@@ -3853,6 +3891,7 @@ final class MessageSchema<T> implements Schema<T> {
 if (extensionRegistry == null) {
 throw new NullPointerException();
 }
+ checkMutable(message);
 mergeFromHelper(unknownFieldSchema, extensionSchema, message, reader, extensionRegistry);
 }
 
@@ -3889,6 +3928,7 @@ final class MessageSchema<T> implements Schema<T> {
 }
 unknownFields =
 extensionSchema.parseExtension(
+ message,
 reader,
 extension,
 extensionRegistry,
@@ -3955,21 +3995,10 @@ final class MessageSchema<T> implements Schema<T> {
 break;
 case 9:
 { // MESSAGE:
- if (isFieldPresent(message, pos)) {
- Object mergedResult =
- Internal.mergeMessage(
- UnsafeUtil.getObject(message, offset(typeAndOffset)),
- reader.readMessageBySchemaWithCheck(
- (Schema<T>) getMessageFieldSchema(pos), extensionRegistry));
- UnsafeUtil.putObject(message, offset(typeAndOffset), mergedResult);
- } else {
- UnsafeUtil.putObject(
- message,
- offset(typeAndOffset),
- reader.readMessageBySchemaWithCheck(
- (Schema<T>) getMessageFieldSchema(pos), extensionRegistry));
- setFieldPresent(message, pos);
- }
+ final MessageLite current = (MessageLite) mutableMessageFieldForMerge(message, pos);
+ reader.mergeMessageField(
+ current, (Schema<MessageLite>) getMessageFieldSchema(pos), extensionRegistry);
+ storeMessageField(message, pos, current);
 break;
 }
 case 10: // BYTES:
@@ -3990,7 +4019,7 @@ final class MessageSchema<T> implements Schema<T> {
 } else {
 unknownFields =
 SchemaUtil.storeUnknownEnum(
- number, enumValue, unknownFields, unknownFieldSchema);
+ message, number, enumValue, unknownFields, unknownFieldSchema);
 }
 break;
 }
@@ -4012,21 +4041,10 @@ final class MessageSchema<T> implements Schema<T> {
 break;
 case 17:
 { // GROUP:
- if (isFieldPresent(message, pos)) {
- Object mergedResult =
- Internal.mergeMessage(
- UnsafeUtil.getObject(message, offset(typeAndOffset)),
- reader.readGroupBySchemaWithCheck(
- (Schema<T>) getMessageFieldSchema(pos), extensionRegistry));
- UnsafeUtil.putObject(message, offset(typeAndOffset), mergedResult);
- } else {
- UnsafeUtil.putObject(
- message,
- offset(typeAndOffset),
- reader.readGroupBySchemaWithCheck(
- (Schema<T>) getMessageFieldSchema(pos), extensionRegistry));
- setFieldPresent(message, pos);
- }
+ final MessageLite current = (MessageLite) mutableMessageFieldForMerge(message, pos);
+ reader.mergeGroupField(
+ current, (Schema<MessageLite>) getMessageFieldSchema(pos), extensionRegistry);
+ storeMessageField(message, pos, current);
 break;
 }
 case 18: // DOUBLE_LIST:
@@ -4089,6 +4107,7 @@ final class MessageSchema<T> implements Schema<T> {
 reader.readEnumList(enumList);
 unknownFields =
 SchemaUtil.filterUnknownEnumList(
+ message,
 number,
 enumList,
 getEnumFieldVerifier(pos),
@@ -4155,6 +4174,7 @@ final class MessageSchema<T> implements Schema<T> {
 reader.readEnumList(enumList);
 unknownFields =
 SchemaUtil.filterUnknownEnumList(
+ message,
 number,
 enumList,
 getEnumFieldVerifier(pos),
@@ -4235,24 +4255,15 @@ final class MessageSchema<T> implements Schema<T> {
 readString(message, typeAndOffset, reader);
 setOneofPresent(message, number, pos);
 break;
- case 60: // ONEOF_MESSAGE:
- if (isOneofPresent(message, number, pos)) {
- Object mergedResult =
- Internal.mergeMessage(
- UnsafeUtil.getObject(message, offset(typeAndOffset)),
- reader.readMessageBySchemaWithCheck(
- getMessageFieldSchema(pos), extensionRegistry));
- UnsafeUtil.putObject(message, offset(typeAndOffset), mergedResult);
- } else {
- UnsafeUtil.putObject(
- message,
- offset(typeAndOffset),
- reader.readMessageBySchemaWithCheck(
- getMessageFieldSchema(pos), extensionRegistry));
- setFieldPresent(message, pos);
+ case 60:
+ { // ONEOF_MESSAGE:
+ final MessageLite current =
+ (MessageLite) mutableOneofMessageFieldForMerge(message, number, pos);
+ reader.mergeMessageField(
+ current, (Schema<MessageLite>) getMessageFieldSchema(pos), extensionRegistry);
+ storeOneofMessageField(message, number, pos, current);
+ break;
 }
- setOneofPresent(message, number, pos);
- break;
 case 61: // ONEOF_BYTES:
 UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes());
 setOneofPresent(message, number, pos);
@@ -4272,7 +4283,7 @@ final class MessageSchema<T> implements Schema<T> {
 } else {
 unknownFields =
 SchemaUtil.storeUnknownEnum(
- number, enumValue, unknownFields, unknownFieldSchema);
+ message, number, enumValue, unknownFields, unknownFieldSchema);
 }
 break;
 }
@@ -4296,17 +4307,19 @@ final class MessageSchema<T> implements Schema<T> {
 message, offset(typeAndOffset), Long.valueOf(reader.readSInt64()));
 setOneofPresent(message, number, pos);
 break;
- case 68: // ONEOF_GROUP:
- UnsafeUtil.putObject(
- message,
- offset(typeAndOffset),
- reader.readGroupBySchemaWithCheck(getMessageFieldSchema(pos), extensionRegistry));
- setOneofPresent(message, number, pos);
- break;
+ case 68:
+ { // ONEOF_GROUP:
+ final MessageLite current =
+ (MessageLite) mutableOneofMessageFieldForMerge(message, number, pos);
+ reader.mergeGroupField(
+ current, (Schema<MessageLite>) getMessageFieldSchema(pos), extensionRegistry);
+ storeOneofMessageField(message, number, pos, current);
+ break;
+ }
 default:
 // Assume we've landed on an empty entry. Treat it as an unknown field.
 if (unknownFields == null) {
- unknownFields = unknownFieldSchema.newBuilder();
+ unknownFields = unknownFieldSchema.getBuilderFromMessage(message);
 }
 if (!unknownFieldSchema.mergeOneFieldFrom(unknownFields, reader)) {
 return;
@@ -4333,7 +4346,8 @@ final class MessageSchema<T> implements Schema<T> {
 } finally {
 for (int i = checkInitializedCount; i < repeatedFieldOffsetStart; i++) {
 unknownFields =
- filterMapUnknownEnumValues(message, intArray[i], unknownFields, unknownFieldSchema);
+ filterMapUnknownEnumValues(
+ message, intArray[i], unknownFields, unknownFieldSchema, message);
 }
 if (unknownFields != null) {
 unknownFieldSchema.setBuilderToMessage(message, unknownFields);
@@ -4343,6 +4357,8 @@ final class MessageSchema<T> implements Schema<T> {
 
 @SuppressWarnings("ReferenceEquality")
 static UnknownFieldSetLite getMutableUnknownFields(Object message) {
+ // TODO(b/248560713) decide if we're keeping support for Full in schema classes and handle this
+ // better.
 UnknownFieldSetLite unknownFields = ((GeneratedMessageLite) message).unknownFields;
 if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
 unknownFields = UnknownFieldSetLite.newInstance();
@@ -4603,24 +4619,13 @@ final class MessageSchema<T> implements Schema<T> {
 } else {
 break;
 }
- UnknownFieldSetLite unknownFields = ((GeneratedMessageLite) message).unknownFields;
- if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
- // filterUnknownEnumList() expects the unknownFields parameter to be mutable or null.
- // Since we don't know yet whether there exist unknown enum values, we'd better pass
- // null to it instead of allocating a mutable instance. This is also needed to be
- // consistent with the behavior of generated parser/builder.
- unknownFields = null;
- }
- unknownFields =
- SchemaUtil.filterUnknownEnumList(
- number,
- (ProtobufList<Integer>) list,
- getEnumFieldVerifier(bufferPosition),
- unknownFields,
- (UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite>) unknownFieldSchema);
- if (unknownFields != null) {
- ((GeneratedMessageLite) message).unknownFields = unknownFields;
- }
+ SchemaUtil.filterUnknownEnumList(
+ message,
+ number,
+ (ProtobufList<Integer>) list,
+ getEnumFieldVerifier(bufferPosition),
+ null,
+ (UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite>) unknownFieldSchema);
 break;
 case 33: // SINT32_LIST:
 case 47: // SINT32_LIST_PACKED:
@@ -4774,20 +4779,11 @@ final class MessageSchema<T> implements Schema<T> {
 break;
 case 60: // ONEOF_MESSAGE:
 if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ final Object current = mutableOneofMessageFieldForMerge(message, number, bufferPosition);
 position =
- decodeMessageField(
- getMessageFieldSchema(bufferPosition), data, position, limit, registers);
- final Object oldValue =
- unsafe.getInt(message, oneofCaseOffset) == number
- ? unsafe.getObject(message, fieldOffset)
- : null;
- if (oldValue == null) {
- unsafe.putObject(message, fieldOffset, registers.object1);
- } else {
- unsafe.putObject(
- message, fieldOffset, Internal.mergeMessage(oldValue, registers.object1));
- }
- unsafe.putInt(message, oneofCaseOffset, number);
+ mergeMessageField(
+ current, getMessageFieldSchema(bufferPosition), data, position, limit, registers);
+ storeOneofMessageField(message, number, bufferPosition, current);
 }
 break;
 case 61: // ONEOF_BYTES:
@@ -4827,21 +4823,18 @@ final class MessageSchema<T> implements Schema<T> {
 break;
 case 68: // ONEOF_GROUP:
 if (wireType == WireFormat.WIRETYPE_START_GROUP) {
+ final Object current = mutableOneofMessageFieldForMerge(message, number, bufferPosition);
 final int endTag = (tag & ~0x7) | WireFormat.WIRETYPE_END_GROUP;
 position =
- decodeGroupField(
- getMessageFieldSchema(bufferPosition), data, position, limit, endTag, registers);
- final Object oldValue =
- unsafe.getInt(message, oneofCaseOffset) == number
- ? unsafe.getObject(message, fieldOffset)
- : null;
- if (oldValue == null) {
- unsafe.putObject(message, fieldOffset, registers.object1);
- } else {
- unsafe.putObject(
- message, fieldOffset, Internal.mergeMessage(oldValue, registers.object1));
- }
- unsafe.putInt(message, oneofCaseOffset, number);
+ mergeGroupField(
+ current,
+ getMessageFieldSchema(bufferPosition),
+ data,
+ position,
+ limit,
+ endTag,
+ registers);
+ storeOneofMessageField(message, number, bufferPosition, current);
 }
 break;
 default:
@@ -4878,6 +4871,7 @@ final class MessageSchema<T> implements Schema<T> {
 int parseProto2Message(
 T message, byte[] data, int position, int limit, int endGroup, Registers registers)
 throws IOException {
+ checkMutable(message);
 final sun.misc.Unsafe unsafe = UNSAFE;
 int currentPresenceFieldOffset = NO_PRESENCE_SENTINEL;
 int currentPresenceField = 0;
@@ -4994,18 +4988,11 @@ final class MessageSchema<T> implements Schema<T> {
 break;
 case 9: // MESSAGE
 if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ final Object current = mutableMessageFieldForMerge(message, pos);
 position =
- decodeMessageField(
- getMessageFieldSchema(pos), data, position, limit, registers);
- if ((currentPresenceField & presenceMask) == 0) {
- unsafe.putObject(message, fieldOffset, registers.object1);
- } else {
- unsafe.putObject(
- message,
- fieldOffset,
- Internal.mergeMessage(
- unsafe.getObject(message, fieldOffset), registers.object1));
- }
+ mergeMessageField(
+ current, getMessageFieldSchema(pos), data, position, limit, registers);
+ storeMessageField(message, pos, current);
 currentPresenceField |= presenceMask;
 continue;
 }
@@ -5054,20 +5041,18 @@ final class MessageSchema<T> implements Schema<T> {
 break;
 case 17: // GROUP
 if (wireType == WireFormat.WIRETYPE_START_GROUP) {
+ final Object current = mutableMessageFieldForMerge(message, pos);
 final int endTag = (number << 3) | WireFormat.WIRETYPE_END_GROUP;
 position =
- decodeGroupField(
- getMessageFieldSchema(pos), data, position, limit, endTag, registers);
- if ((currentPresenceField & presenceMask) == 0) {
- unsafe.putObject(message, fieldOffset, registers.object1);
- } else {
- unsafe.putObject(
- message,
- fieldOffset,
- Internal.mergeMessage(
- unsafe.getObject(message, fieldOffset), registers.object1));
- }
-
+ mergeGroupField(
+ current,
+ getMessageFieldSchema(pos),
+ data,
+ position,
+ limit,
+ endTag,
+ registers);
+ storeMessageField(message, pos, current);
 currentPresenceField |= presenceMask;
 continue;
 }
@@ -5165,7 +5150,8 @@ final class MessageSchema<T> implements Schema<T> {
 message,
 intArray[i],
 unknownFields,
- (UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite>) unknownFieldSchema);
+ (UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite>) unknownFieldSchema,
+ message);
 }
 if (unknownFields != null) {
 ((UnknownFieldSchema<UnknownFieldSetLite, UnknownFieldSetLite>) unknownFieldSchema)
@@ -5183,9 +5169,65 @@ final class MessageSchema<T> implements Schema<T> {
 return position;
 }
 
+ private Object mutableMessageFieldForMerge(T message, int pos) {
+ final Schema fieldSchema = getMessageFieldSchema(pos);
+ final long offset = offset(typeAndOffsetAt(pos));
+
+ // Field not present, create a new one
+ if (!isFieldPresent(message, pos)) {
+ return fieldSchema.newInstance();
+ }
+
+ // Field present, if mutable, ready to merge
+ final Object current = UNSAFE.getObject(message, offset);
+ if (isMutable(current)) {
+ return current;
+ }
+
+ // Field present but immutable, make a new mutable copy
+ final Object newMessage = fieldSchema.newInstance();
+ if (current != null) {
+ fieldSchema.mergeFrom(newMessage, current);
+ }
+ return newMessage;
+ }
+
+ private void storeMessageField(T message, int pos, Object field) {
+ UNSAFE.putObject(message, offset(typeAndOffsetAt(pos)), field);
+ setFieldPresent(message, pos);
+ }
+
+ private Object mutableOneofMessageFieldForMerge(T message, int fieldNumber, int pos) {
+ final Schema fieldSchema = getMessageFieldSchema(pos);
+
+ // Field not present, create it and mark it present
+ if (!isOneofPresent(message, fieldNumber, pos)) {
+ return fieldSchema.newInstance();
+ }
+
+ // Field present, if mutable, ready to merge
+ final Object current = UNSAFE.getObject(message, offset(typeAndOffsetAt(pos)));
+ if (isMutable(current)) {
+ return current;
+ }
+
+ // Field present but immutable, make a new mutable copy
+ final Object newMessage = fieldSchema.newInstance();
+ if (current != null) {
+ fieldSchema.mergeFrom(newMessage, current);
+ }
+ return newMessage;
+ }
+
+ private void storeOneofMessageField(T message, int fieldNumber, int pos, Object field) {
+ UNSAFE.putObject(message, offset(typeAndOffsetAt(pos)), field);
+ setOneofPresent(message, fieldNumber, pos);
+ }
+
 /** Parses a proto3 message and returns the limit if parsing is successful. */
 private int parseProto3Message(
 T message, byte[] data, int position, int limit, Registers registers) throws IOException {
+ checkMutable(message);
 final sun.misc.Unsafe unsafe = UNSAFE;
 int currentPresenceFieldOffset = NO_PRESENCE_SENTINEL;
 int currentPresenceField = 0;
@@ -5307,16 +5349,11 @@ final class MessageSchema<T> implements Schema<T> {
 break;
 case 9: // MESSAGE:
 if (wireType == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+ final Object current = mutableMessageFieldForMerge(message, pos);
 position =
- decodeMessageField(
- getMessageFieldSchema(pos), data, position, limit, registers);
- final Object oldValue = unsafe.getObject(message, fieldOffset);
- if (oldValue == null) {
- unsafe.putObject(message, fieldOffset, registers.object1);
- } else {
- unsafe.putObject(
- message, fieldOffset, Internal.mergeMessage(oldValue, registers.object1));
- }
+ mergeMessageField(
+ current, getMessageFieldSchema(pos), data, position, limit, registers);
+ storeMessageField(message, pos, current);
 currentPresenceField |= presenceMask;
 continue;
 }
@@ -5447,18 +5484,73 @@ final class MessageSchema<T> implements Schema<T> {
 
 @Override
 public void makeImmutable(T message) {
- // Make all repeated/map fields immutable.
- for (int i = checkInitializedCount; i < repeatedFieldOffsetStart; i++) {
- long offset = offset(typeAndOffsetAt(intArray[i]));
- Object mapField = UnsafeUtil.getObject(message, offset);
- if (mapField == null) {
- continue;
- }
- UnsafeUtil.putObject(message, offset, mapFieldSchema.toImmutable(mapField));
+ if (!isMutable(message)) {
+ return;
+ }
+
+ // TODO(b/248560713) decide if we're keeping support for Full in schema classes and handle this
+ // better.
+ if (message instanceof GeneratedMessageLite) {
+ GeneratedMessageLite<?, ?> generatedMessage = ((GeneratedMessageLite<?, ?>) message);
+ generatedMessage.clearMemoizedSerializedSize();
+ generatedMessage.clearMemoizedHashCode();
+ generatedMessage.markImmutable();
 }
- final int length = intArray.length;
- for (int i = repeatedFieldOffsetStart; i < length; i++) {
- listFieldSchema.makeImmutableListAt(message, intArray[i]);
+
+ final int bufferLength = buffer.length;
+ for (int pos = 0; pos < bufferLength; pos += INTS_PER_FIELD) {
+ final int typeAndOffset = typeAndOffsetAt(pos);
+ final long offset = offset(typeAndOffset);
+ switch (type(typeAndOffset)) {
+ case 17: // GROUP
+ case 9: // MESSAGE
+ if (isFieldPresent(message, pos)) {
+ getMessageFieldSchema(pos).makeImmutable(UNSAFE.getObject(message, offset));
+ }
+ break;
+ case 18: // DOUBLE_LIST:
+ case 19: // FLOAT_LIST:
+ case 20: // INT64_LIST:
+ case 21: // UINT64_LIST:
+ case 22: // INT32_LIST:
+ case 23: // FIXED64_LIST:
+ case 24: // FIXED32_LIST:
+ case 25: // BOOL_LIST:
+ case 26: // STRING_LIST:
+ case 27: // MESSAGE_LIST:
+ case 28: // BYTES_LIST:
+ case 29: // UINT32_LIST:
+ case 30: // ENUM_LIST:
+ case 31: // SFIXED32_LIST:
+ case 32: // SFIXED64_LIST:
+ case 33: // SINT32_LIST:
+ case 34: // SINT64_LIST:
+ case 35: // DOUBLE_LIST_PACKED:
+ case 36: // FLOAT_LIST_PACKED:
+ case 37: // INT64_LIST_PACKED:
+ case 38: // UINT64_LIST_PACKED:
+ case 39: // INT32_LIST_PACKED:
+ case 40: // FIXED64_LIST_PACKED:
+ case 41: // FIXED32_LIST_PACKED:
+ case 42: // BOOL_LIST_PACKED:
+ case 43: // UINT32_LIST_PACKED:
+ case 44: // ENUM_LIST_PACKED:
+ case 45: // SFIXED32_LIST_PACKED:
+ case 46: // SFIXED64_LIST_PACKED:
+ case 47: // SINT32_LIST_PACKED:
+ case 48: // SINT64_LIST_PACKED:
+ case 49: // GROUP_LIST:
+ listFieldSchema.makeImmutableListAt(message, offset);
+ break;
+ case 50: // MAP:
+ {
+ Object mapField = UNSAFE.getObject(message, offset);
+ if (mapField != null) {
+ UNSAFE.putObject(message, offset, mapFieldSchema.toImmutable(mapField));
+ }
+ }
+ break;
+ }
 }
 unknownFieldSchema.makeImmutable(message);
 if (hasExtensions) {
@@ -5495,8 +5587,12 @@ final class MessageSchema<T> implements Schema<T> {
 extensionRegistry);
 }
 
- private final <UT, UB> UB filterMapUnknownEnumValues(
- Object message, int pos, UB unknownFields, UnknownFieldSchema<UT, UB> unknownFieldSchema) {
+ private <UT, UB> UB filterMapUnknownEnumValues(
+ Object message,
+ int pos,
+ UB unknownFields,
+ UnknownFieldSchema<UT, UB> unknownFieldSchema,
+ Object containerMessage) {
 int fieldNumber = numberAt(pos);
 long offset = offset(typeAndOffsetAt(pos));
 Object mapField = UnsafeUtil.getObject(message, offset);
@@ -5511,25 +5607,32 @@ final class MessageSchema<T> implements Schema<T> {
 // Filter unknown enum values.
 unknownFields =
 filterUnknownEnumMap(
- pos, fieldNumber, mapData, enumVerifier, unknownFields, unknownFieldSchema);
+ pos,
+ fieldNumber,
+ mapData,
+ enumVerifier,
+ unknownFields,
+ unknownFieldSchema,
+ containerMessage);
 return unknownFields;
 }
 
 @SuppressWarnings("unchecked")
- private final <K, V, UT, UB> UB filterUnknownEnumMap(
+ private <K, V, UT, UB> UB filterUnknownEnumMap(
 int pos,
 int number,
 Map<K, V> mapData,
 EnumVerifier enumVerifier,
 UB unknownFields,
- UnknownFieldSchema<UT, UB> unknownFieldSchema) {
+ UnknownFieldSchema<UT, UB> unknownFieldSchema,
+ Object containerMessage) {
 Metadata<K, V> metadata =
 (Metadata<K, V>) mapFieldSchema.forMapMetadata(getMapFieldDefaultEntry(pos));
 for (Iterator<Map.Entry<K, V>> it = mapData.entrySet().iterator(); it.hasNext(); ) {
 Map.Entry<K, V> entry = it.next();
 if (!enumVerifier.isInRange((Integer) entry.getValue())) {
 if (unknownFields == null) {
- unknownFields = unknownFieldSchema.newBuilder();
+ unknownFields = unknownFieldSchema.getBuilderFromMessage(containerMessage);
 }
 int entrySize =
 MapEntryLite.computeSerializedSize(metadata, entry.getKey(), entry.getValue());
@@ -5746,6 +5849,28 @@ final class MessageSchema<T> implements Schema<T> {
 return value & OFFSET_MASK;
 }
 
+ private static boolean isMutable(Object message) {
+ if (message == null) {
+ return false;
+ }
+
+ // TODO(b/248560713) decide if we're keeping support for Full in schema classes and handle this
+ // better.
+ if (message instanceof GeneratedMessageLite<?, ?>) {
+ return ((GeneratedMessageLite<?, ?>) message).isMutable();
+ }
+
+ // For other types, we'll assume this is true because that's what was
+ // happening before we started checking.
+ return true;
+ }
+
+ private static void checkMutable(Object message) {
+ if (!isMutable(message)) {
+ throw new IllegalArgumentException("Mutating immutable message: " + message);
+ }
+ }
+
 private static <T> double doubleAt(T message, long offset) {
 return UnsafeUtil.getDouble(message, offset);
 }
diff --git a/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java b/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java
index 187dc8b..eae93b9 100644
--- a/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java
+++ b/java/core/src/main/java/com/google/protobuf/MessageSetSchema.java
@@ -61,7 +61,13 @@ final class MessageSetSchema<T> implements Schema<T> {
 @SuppressWarnings("unchecked")
 @Override
 public T newInstance() {
- return (T) defaultInstance.newBuilderForType().buildPartial();
+ // TODO(b/248560713) decide if we're keeping support for Full in schema classes and handle this
+ // better.
+ if (defaultInstance instanceof GeneratedMessageLite) {
+ return (T) ((GeneratedMessageLite<?, ?>) defaultInstance).newMutableInstance();
+ } else {
+ return (T) defaultInstance.newBuilderForType().buildPartial();
+ }
 }
 
 @Override
@@ -132,6 +138,8 @@ final class MessageSetSchema<T> implements Schema<T> {
 public void mergeFrom(
 T message, byte[] data, int position, int limit, ArrayDecoders.Registers registers)
 throws IOException {
+ // TODO(b/248560713) decide if we're keeping support for Full in schema classes and handle this
+ // better.
 UnknownFieldSetLite unknownFields = ((GeneratedMessageLite) message).unknownFields;
 if (unknownFields == UnknownFieldSetLite.getDefaultInstance()) {
 unknownFields = UnknownFieldSetLite.newInstance();
@@ -180,9 +188,12 @@ final class MessageSetSchema<T> implements Schema<T> {
 if (wireType == WireFormat.WIRETYPE_VARINT) {
 position = ArrayDecoders.decodeVarint32(data, position, registers);
 typeId = registers.int1;
+ // TODO(b/248560713) decide if we're keeping support for Full in schema classes and
+ // handle this better.
 extension =
- (GeneratedMessageLite.GeneratedExtension<?, ?>) extensionSchema
- .findExtensionByNumber(registers.extensionRegistry, defaultInstance, typeId);
+ (GeneratedMessageLite.GeneratedExtension<?, ?>)
+ extensionSchema.findExtensionByNumber(
+ registers.extensionRegistry, defaultInstance, typeId);
 continue;
 }
 break;
diff --git a/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaLite.java b/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaLite.java
index 9b92266..00cfe3b 100644
--- a/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaLite.java
+++ b/java/core/src/main/java/com/google/protobuf/NewInstanceSchemaLite.java
@@ -33,7 +33,8 @@ package com.google.protobuf;
 final class NewInstanceSchemaLite implements NewInstanceSchema {
 @Override
 public Object newInstance(Object defaultInstance) {
- return ((GeneratedMessageLite) defaultInstance)
- .dynamicMethod(GeneratedMessageLite.MethodToInvoke.NEW_MUTABLE_INSTANCE);
+ // TODO(b/248560713) decide if we're keeping support for Full in schema classes and handle this
+ // better.
+ return ((GeneratedMessageLite<?, ?>) defaultInstance).newMutableInstance();
 }
 }
diff --git a/java/core/src/main/java/com/google/protobuf/Reader.java b/java/core/src/main/java/com/google/protobuf/Reader.java
index 705096f..b99ee43 100644
--- a/java/core/src/main/java/com/google/protobuf/Reader.java
+++ b/java/core/src/main/java/com/google/protobuf/Reader.java
@@ -158,6 +158,14 @@ interface Reader {
 <T> T readGroupBySchemaWithCheck(Schema<T> schema, ExtensionRegistryLite extensionRegistry)
 throws IOException;
 
+ /** Read a message field from the wire format and merge the results into the given target. */
+ <T> void mergeMessageField(T target, Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException;
+
+ /** Read a group field from the wire format and merge the results into the given target. */
+ <T> void mergeGroupField(T target, Schema<T> schema, ExtensionRegistryLite extensionRegistry)
+ throws IOException;
+
 /**
 * Reads and returns the next field of type {@code BYTES} and advances the reader to the next
 * field.
diff --git a/java/core/src/main/java/com/google/protobuf/SchemaUtil.java b/java/core/src/main/java/com/google/protobuf/SchemaUtil.java
index 4c8bb06..0e4c42c 100644
--- a/java/core/src/main/java/com/google/protobuf/SchemaUtil.java
+++ b/java/core/src/main/java/com/google/protobuf/SchemaUtil.java
@@ -59,6 +59,8 @@ final class SchemaUtil {
 * GeneratedMessageLite}.
 */
 public static void requireGeneratedMessage(Class<?> messageType) {
+ // TODO(b/248560713) decide if we're keeping support for Full in schema classes and handle this
+ // better.
 if (!GeneratedMessageLite.class.isAssignableFrom(messageType)
 && GENERATED_MESSAGE_CLASS != null
 && !GENERATED_MESSAGE_CLASS.isAssignableFrom(messageType)) {
@@ -808,6 +810,8 @@ final class SchemaUtil {
 
 private static Class<?> getGeneratedMessageClass() {
 try {
+ // TODO(b/248560713) decide if we're keeping support for Full in schema classes and handle
+ // this better.
 return Class.forName("com.google.protobuf.GeneratedMessageV3");
 } catch (Throwable e) {
 return null;
@@ -901,6 +905,7 @@ final class SchemaUtil {
 
 /** Filters unrecognized enum values in a list. */
 static <UT, UB> UB filterUnknownEnumList(
+ Object containerMessage,
 int number,
 List<Integer> enumList,
 EnumLiteMap<?> enumMap,
@@ -921,7 +926,9 @@ final class SchemaUtil {
 }
 ++writePos;
 } else {
- unknownFields = storeUnknownEnum(number, enumValue, unknownFields, unknownFieldSchema);
+ unknownFields =
+ storeUnknownEnum(
+ containerMessage, number, enumValue, unknownFields, unknownFieldSchema);
 }
 }
 if (writePos != size) {
@@ -931,7 +938,9 @@ final class SchemaUtil {
 for (Iterator<Integer> it = enumList.iterator(); it.hasNext(); ) {
 int enumValue = it.next();
 if (enumMap.findValueByNumber(enumValue) == null) {
- unknownFields = storeUnknownEnum(number, enumValue, unknownFields, unknownFieldSchema);
+ unknownFields =
+ storeUnknownEnum(
+ containerMessage, number, enumValue, unknownFields, unknownFieldSchema);
 it.remove();
 }
 }
@@ -941,6 +950,7 @@ final class SchemaUtil {
 
 /** Filters unrecognized enum values in a list. */
 static <UT, UB> UB filterUnknownEnumList(
+ Object containerMessage,
 int number,
 List<Integer> enumList,
 EnumVerifier enumVerifier,
@@ -961,7 +971,9 @@ final class SchemaUtil {
 }
 ++writePos;
 } else {
- unknownFields = storeUnknownEnum(number, enumValue, unknownFields, unknownFieldSchema);
+ unknownFields =
+ storeUnknownEnum(
+ containerMessage, number, enumValue, unknownFields, unknownFieldSchema);
 }
 }
 if (writePos != size) {
@@ -971,7 +983,9 @@ final class SchemaUtil {
 for (Iterator<Integer> it = enumList.iterator(); it.hasNext(); ) {
 int enumValue = it.next();
 if (!enumVerifier.isInRange(enumValue)) {
- unknownFields = storeUnknownEnum(number, enumValue, unknownFields, unknownFieldSchema);
+ unknownFields =
+ storeUnknownEnum(
+ containerMessage, number, enumValue, unknownFields, unknownFieldSchema);
 it.remove();
 }
 }
@@ -981,9 +995,13 @@ final class SchemaUtil {
 
 /** Stores an unrecognized enum value as an unknown value. */
 static <UT, UB> UB storeUnknownEnum(
- int number, int enumValue, UB unknownFields, UnknownFieldSchema<UT, UB> unknownFieldSchema) {
+ Object containerMessage,
+ int number,
+ int enumValue,
+ UB unknownFields,
+ UnknownFieldSchema<UT, UB> unknownFieldSchema) {
 if (unknownFields == null) {
- unknownFields = unknownFieldSchema.newBuilder();
+ unknownFields = unknownFieldSchema.getBuilderFromMessage(containerMessage);
 }
 unknownFieldSchema.addVarint(unknownFields, number, enumValue);
 return unknownFields;
diff --git a/java/core/src/main/java/com/google/protobuf/TextFormat.java b/java/core/src/main/java/com/google/protobuf/TextFormat.java
index bbc0f8d..a5709cc 100644
--- a/java/core/src/main/java/com/google/protobuf/TextFormat.java
+++ b/java/core/src/main/java/com/google/protobuf/TextFormat.java
@@ -593,7 +593,7 @@ public final class TextFormat {
 
 case MESSAGE:
 case GROUP:
- print((Message) value, generator);
+ print((MessageOrBuilder) value, generator);
 break;
 }
 }
diff --git a/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLite.java b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLite.java
index b2cb7be..37a14e2 100644
--- a/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLite.java
+++ b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLite.java
@@ -388,7 +388,7 @@ public final class UnknownFieldSetLite {
 // Package private for unsafe experimental runtime.
 void storeField(int tag, Object value) {
 checkMutable();
- ensureCapacity();
+ ensureCapacity(count + 1);
 
 tags[count] = tag;
 objects[count] = value;
@@ -396,13 +396,23 @@ public final class UnknownFieldSetLite {
 }
 
 /** Ensures that our arrays are long enough to store more metadata. */
- private void ensureCapacity() {
- if (count == tags.length) {
- int increment = count < (MIN_CAPACITY / 2) ? MIN_CAPACITY : count >> 1;
- int newLength = count + increment;
+ private void ensureCapacity(int minCapacity) {
+ if (minCapacity > this.tags.length) {
+ // Increase by at least 50%
+ int newCapacity = count + count / 2;
+
+ // Or new capacity if higher
+ if (newCapacity < minCapacity) {
+ newCapacity = minCapacity;
+ }
+
+ // And never less than MIN_CAPACITY
+ if (newCapacity < MIN_CAPACITY) {
+ newCapacity = MIN_CAPACITY;
+ }
 
- tags = Arrays.copyOf(tags, newLength);
- objects = Arrays.copyOf(objects, newLength);
+ this.tags = Arrays.copyOf(this.tags, newCapacity);
+ this.objects = Arrays.copyOf(this.objects, newCapacity);
 }
 }
 
@@ -487,4 +497,18 @@ public final class UnknownFieldSetLite {
 }
 return this;
 }
+
+ UnknownFieldSetLite mergeFrom(UnknownFieldSetLite other) {
+ if (other.equals(getDefaultInstance())) {
+ return this;
+ }
+
+ checkMutable();
+ int newCount = this.count + other.count;
+ ensureCapacity(newCount);
+ System.arraycopy(other.tags, 0, tags, this.count, other.count);
+ System.arraycopy(other.objects, 0, objects, this.count, other.count);
+ this.count = newCount;
+ return this;
+ }
 }
diff --git a/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLiteSchema.java b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLiteSchema.java
index ffd7232..2cfdeca 100644
--- a/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLiteSchema.java
+++ b/java/core/src/main/java/com/google/protobuf/UnknownFieldSetLiteSchema.java
@@ -122,10 +122,14 @@ class UnknownFieldSetLiteSchema
 }
 
 @Override
- UnknownFieldSetLite merge(UnknownFieldSetLite message, UnknownFieldSetLite other) {
- return other.equals(UnknownFieldSetLite.getDefaultInstance())
- ? message
- : UnknownFieldSetLite.mutableCopyOf(message, other);
+ UnknownFieldSetLite merge(UnknownFieldSetLite target, UnknownFieldSetLite source) {
+ if (UnknownFieldSetLite.getDefaultInstance().equals(source)) {
+ return target;
+ }
+ if (UnknownFieldSetLite.getDefaultInstance().equals(target)) {
+ return UnknownFieldSetLite.mutableCopyOf(target, source);
+ }
+ return target.mergeFrom(source);
 }
 
 @Override
diff --git a/java/lite/src/test/java/com/google/protobuf/LiteTest.java b/java/lite/src/test/java/com/google/protobuf/LiteTest.java
index 140df72..7481b69 100644
--- a/java/lite/src/test/java/com/google/protobuf/LiteTest.java
+++ b/java/lite/src/test/java/com/google/protobuf/LiteTest.java
@@ -49,15 +49,6 @@ import com.google.protobuf.UnittestLite.TestAllTypesLite.RepeatedGroup;
 import com.google.protobuf.UnittestLite.TestAllTypesLiteOrBuilder;
 import com.google.protobuf.UnittestLite.TestHugeFieldNumbersLite;
 import com.google.protobuf.UnittestLite.TestNestedExtensionLite;
-import map_lite_test.MapTestProto.TestMap;
-import map_lite_test.MapTestProto.TestMap.MessageValue;
-import protobuf_unittest.NestedExtensionLite;
-import protobuf_unittest.NonNestedExtensionLite;
-import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Bar;
-import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.BarPrime;
-import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Foo;
-import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestOneofEquals;
-import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestRecursiveOneof;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -69,6 +60,15 @@ import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 import junit.framework.TestCase;
+import map_lite_test.MapTestProto.TestMap;
+import map_lite_test.MapTestProto.TestMap.MessageValue;
+import protobuf_unittest.NestedExtensionLite;
+import protobuf_unittest.NonNestedExtensionLite;
+import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Bar;
+import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.BarPrime;
+import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Foo;
+import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestOneofEquals;
+import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestRecursiveOneof;
 
 /**
 * Test lite runtime.
@@ -181,16 +181,24 @@ public class LiteTest extends TestCase {
 TestAllExtensionsLite message = TestUtilLite.getAllLiteExtensionsSet();
 
 // Test serialized size is memoized
- message.memoizedSerializedSize = -1;
+ assertEquals(
+ GeneratedMessageLite.UNINITIALIZED_SERIALIZED_SIZE,
+ message.getMemoizedSerializedSize());
 int size = message.getSerializedSize();
 assertTrue(size > 0);
- assertEquals(size, message.memoizedSerializedSize);
+ assertEquals(size, message.getMemoizedSerializedSize());
+ message.clearMemoizedSerializedSize();
+ assertEquals(
+ GeneratedMessageLite.UNINITIALIZED_SERIALIZED_SIZE,
+ message.getMemoizedSerializedSize());
 
 // Test hashCode is memoized
- assertEquals(0, message.memoizedHashCode);
+ assertTrue(message.hashCodeIsNotMemoized());
 int hashCode = message.hashCode();
- assertTrue(hashCode != 0);
- assertEquals(hashCode, message.memoizedHashCode);
+ assertFalse(message.hashCodeIsNotMemoized());
+ assertEquals(hashCode, message.getMemoizedHashCode());
+ message.clearMemoizedHashCode();
+ assertTrue(message.hashCodeIsNotMemoized());
 
 // Test isInitialized is memoized
 Field memo = message.getClass().getDeclaredField("memoizedIsInitialized");
diff --git a/java/util/src/main/java/com/google/protobuf/util/FieldMaskTree.java b/java/util/src/main/java/com/google/protobuf/util/FieldMaskTree.java
index 352376e..2aa0916 100644
--- a/java/util/src/main/java/com/google/protobuf/util/FieldMaskTree.java
+++ b/java/util/src/main/java/com/google/protobuf/util/FieldMaskTree.java
@@ -35,6 +35,7 @@ import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.protobuf.Descriptors.Descriptor;
 import com.google.protobuf.Descriptors.FieldDescriptor;
 import com.google.protobuf.FieldMask;
+import com.google.protobuf.GeneratedMessage;
 import com.google.protobuf.Message;
 import java.util.ArrayList;
 import java.util.List;
@@ -304,9 +305,12 @@ final class FieldMaskTree {
 // so we don't create unnecessary empty messages.
 continue;
 }
- String childPath = path.isEmpty() ? entry.getKey() : path + "." + entry.getKey();
- Message.Builder childBuilder = ((Message) destination.getField(field)).toBuilder();
- merge(entry.getValue(), childPath, (Message) source.getField(field), childBuilder, options);
+ // This is a mess because of java proto API 1 still hanging around.
+ Message.Builder childBuilder =
+ destination instanceof GeneratedMessage.Builder
+ ? destination.getFieldBuilder(field)
+ : ((Message) destination.getField(field)).toBuilder();
+ merge(entry.getValue(), path, (Message) source.getField(field), childBuilder, options);
 destination.setField(field, childBuilder.buildPartial());
 continue;
 }
diff --git a/src/google/protobuf/compiler/java/java_enum_field.cc b/src/google/protobuf/compiler/java/java_enum_field.cc
index d96ac7d..15626f9 100644
--- a/src/google/protobuf/compiler/java/java_enum_field.cc
+++ b/src/google/protobuf/compiler/java/java_enum_field.cc
@@ -110,13 +110,6 @@ void SetEnumVariables(const FieldDescriptor* descriptor, int messageBitIndex,
 (*variables)["set_mutable_bit_builder"] = GenerateSetBit(builderBitIndex);
 (*variables)["clear_mutable_bit_builder"] = GenerateClearBit(builderBitIndex);
 
- // For repeated fields, one bit is used for whether the array is immutable
- // in the parsing constructor.
- (*variables)["get_mutable_bit_parser"] =
- GenerateGetBitMutableLocal(builderBitIndex);
- (*variables)["set_mutable_bit_parser"] =
- GenerateSetBitMutableLocal(builderBitIndex);
-
 (*variables)["get_has_field_bit_from_local"] =
 GenerateGetBitFromLocal(builderBitIndex);
 (*variables)["set_has_field_bit_to_local"] =
@@ -314,32 +307,26 @@ void ImmutableEnumFieldGenerator::GenerateBuildingCode(
 printer->Print(variables_, "result.$name$_ = $name$_;\n");
 }
 
-void ImmutableEnumFieldGenerator::GenerateParsingCode(
+void ImmutableEnumFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
 if (SupportUnknownEnumValue(descriptor_->file())) {
 printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "$set_has_field_bit_message$\n"
- "$name$_ = rawValue;\n");
+ "$name$_ = input.readEnum();\n"
+ "$set_has_field_bit_builder$\n");
 } else {
 printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- " @SuppressWarnings(\"deprecation\")\n"
- "$type$ value = $type$.$for_number$(rawValue);\n"
- "if (value == null) {\n"
- " unknownFields.mergeVarintField($number$, rawValue);\n"
+ "int tmpRaw = input.readEnum();\n"
+ "$type$ tmpValue =\n"
+ " $type$.forNumber(tmpRaw);\n"
+ "if (tmpValue == null) {\n"
+ " mergeUnknownVarintField($number$, tmpRaw);\n"
 "} else {\n"
- " $set_has_field_bit_message$\n"
- " $name$_ = rawValue;\n"
+ " $name$_ = tmpRaw;\n"
+ " $set_has_field_bit_builder$\n"
 "}\n");
 }
 }
 
-void ImmutableEnumFieldGenerator::GenerateParsingDoneCode(
- io::Printer* printer) const {
- // noop for enums
-}
-
 void ImmutableEnumFieldGenerator::GenerateSerializationCode(
 io::Printer* printer) const {
 printer->Print(variables_,
@@ -502,6 +489,11 @@ void ImmutableEnumOneofFieldGenerator::GenerateBuilderMembers(
 printer->Annotate("{", "}", descriptor_);
 }
 
+void ImmutableEnumOneofFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
+ // No-op: Enum fields in oneofs are correctly cleared by clearing the oneof
+}
+
 void ImmutableEnumOneofFieldGenerator::GenerateBuildingCode(
 io::Printer* printer) const {
 printer->Print(variables_,
@@ -522,7 +514,7 @@ void ImmutableEnumOneofFieldGenerator::GenerateMergingCode(
 }
 }
 
-void ImmutableEnumOneofFieldGenerator::GenerateParsingCode(
+void ImmutableEnumOneofFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
 if (SupportUnknownEnumValue(descriptor_->file())) {
 printer->Print(variables_,
@@ -532,10 +524,10 @@ void ImmutableEnumOneofFieldGenerator::GenerateParsingCode(
 } else {
 printer->Print(variables_,
 "int rawValue = input.readEnum();\n"
- "@SuppressWarnings(\"deprecation\")\n"
- "$type$ value = $type$.$for_number$(rawValue);\n"
+ "$type$ value =\n"
+ " $type$.forNumber(rawValue);\n"
 "if (value == null) {\n"
- " unknownFields.mergeVarintField($number$, rawValue);\n"
+ " mergeUnknownVarintField($number$, rawValue);\n"
 "} else {\n"
 " $set_oneof_case_message$;\n"
 " $oneof_name$_ = rawValue;\n"
@@ -914,36 +906,29 @@ void RepeatedImmutableEnumFieldGenerator::GenerateBuildingCode(
 "result.$name$_ = $name$_;\n");
 }
 
-void RepeatedImmutableEnumFieldGenerator::GenerateParsingCode(
+void RepeatedImmutableEnumFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
 // Read and store the enum
 if (SupportUnknownEnumValue(descriptor_->file())) {
 printer->Print(variables_,
- "int rawValue = input.readEnum();\n"
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = new java.util.ArrayList<java.lang.Integer>();\n"
- " $set_mutable_bit_parser$;\n"
- "}\n"
- "$name$_.add(rawValue);\n");
+ "int tmpRaw = input.readEnum();\n"
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.add(tmpRaw);\n");
 } else {
- printer->Print(
- variables_,
- "int rawValue = input.readEnum();\n"
- "@SuppressWarnings(\"deprecation\")\n"
- "$type$ value = $type$.$for_number$(rawValue);\n"
- "if (value == null) {\n"
- " unknownFields.mergeVarintField($number$, rawValue);\n"
- "} else {\n"
- " if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = new java.util.ArrayList<java.lang.Integer>();\n"
- " $set_mutable_bit_parser$;\n"
- " }\n"
- " $name$_.add(rawValue);\n"
- "}\n");
+ printer->Print(variables_,
+ "int tmpRaw = input.readEnum();\n"
+ "$type$ tmpValue =\n"
+ " $type$.forNumber(tmpRaw);\n"
+ "if (tmpValue == null) {\n"
+ " mergeUnknownVarintField($number$, tmpRaw);\n"
+ "} else {\n"
+ " ensure$capitalized_name$IsMutable();\n"
+ " $name$_.add(tmpRaw);\n"
+ "}\n");
 }
 }
 
-void RepeatedImmutableEnumFieldGenerator::GenerateParsingCodeFromPacked(
+void RepeatedImmutableEnumFieldGenerator::GenerateBuilderParsingCodeFromPacked(
 io::Printer* printer) const {
 // Wrap GenerateParsingCode's contents with a while loop.
 
@@ -953,7 +938,7 @@ void RepeatedImmutableEnumFieldGenerator::GenerateParsingCodeFromPacked(
 "while(input.getBytesUntilLimit() > 0) {\n");
 printer->Indent();
 
- GenerateParsingCode(printer);
+ GenerateBuilderParsingCode(printer);
 
 printer->Outdent();
 printer->Print(variables_,
@@ -961,15 +946,6 @@ void RepeatedImmutableEnumFieldGenerator::GenerateParsingCodeFromPacked(
 "input.popLimit(oldLimit);\n");
 }
 
-void RepeatedImmutableEnumFieldGenerator::GenerateParsingDoneCode(
- io::Printer* printer) const {
- printer->Print(
- variables_,
- "if ($get_mutable_bit_parser$) {\n"
- " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
- "}\n");
-}
-
 void RepeatedImmutableEnumFieldGenerator::GenerateSerializationCode(
 io::Printer* printer) const {
 if (descriptor_->is_packed()) {
diff --git a/src/google/protobuf/compiler/java/java_enum_field.h b/src/google/protobuf/compiler/java/java_enum_field.h
index 95c7db5..318e013 100644
--- a/src/google/protobuf/compiler/java/java_enum_field.h
+++ b/src/google/protobuf/compiler/java/java_enum_field.h
@@ -64,24 +64,24 @@ class ImmutableEnumFieldGenerator : public ImmutableFieldGenerator {
 
 // implements ImmutableFieldGenerator
 // ---------------------------------------
- int GetNumBitsForMessage() const;
- int GetNumBitsForBuilder() const;
- void GenerateInterfaceMembers(io::Printer* printer) const;
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
- std::string GetBoxedType() const;
+ int GetNumBitsForMessage() const override;
+ int GetNumBitsForBuilder() const override;
+ void GenerateInterfaceMembers(io::Printer* printer) const override;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateInitializationCode(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
+
+ std::string GetBoxedType() const override;
 
 protected:
 const FieldDescriptor* descriptor_;
@@ -99,15 +99,16 @@ class ImmutableEnumOneofFieldGenerator : public ImmutableEnumFieldGenerator {
 Context* context);
 ~ImmutableEnumOneofFieldGenerator();
 
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
 
 private:
 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImmutableEnumOneofFieldGenerator);
@@ -121,25 +122,26 @@ class RepeatedImmutableEnumFieldGenerator : public ImmutableFieldGenerator {
 ~RepeatedImmutableEnumFieldGenerator();
 
 // implements ImmutableFieldGenerator ---------------------------------------
- int GetNumBitsForMessage() const;
- int GetNumBitsForBuilder() const;
- void GenerateInterfaceMembers(io::Printer* printer) const;
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingCodeFromPacked(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
- std::string GetBoxedType() const;
+ int GetNumBitsForMessage() const override;
+ int GetNumBitsForBuilder() const override;
+ void GenerateInterfaceMembers(io::Printer* printer) const override;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateInitializationCode(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCodeFromPacked(
+ io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
+
+ std::string GetBoxedType() const override;
 
 private:
 const FieldDescriptor* descriptor_;
diff --git a/src/google/protobuf/compiler/java/java_field.cc b/src/google/protobuf/compiler/java/java_field.cc
index 2f775a6..229b3b3 100644
--- a/src/google/protobuf/compiler/java/java_field.cc
+++ b/src/google/protobuf/compiler/java/java_field.cc
@@ -185,7 +185,7 @@ static inline void ReportUnexpectedPackedFieldsCall(io::Printer* printer) {
 // but this method should be overridden.
 // - This FieldGenerator doesn't support packing, and this method
 // should never have been called.
- GOOGLE_LOG(FATAL) << "GenerateParsingCodeFromPacked() "
+ GOOGLE_LOG(FATAL) << "GenerateBuilderParsingCodeFromPacked() "
 << "called on field generator that does not support packing.";
 }
 
@@ -193,7 +193,7 @@ static inline void ReportUnexpectedPackedFieldsCall(io::Printer* printer) {
 
 ImmutableFieldGenerator::~ImmutableFieldGenerator() {}
 
-void ImmutableFieldGenerator::GenerateParsingCodeFromPacked(
+void ImmutableFieldGenerator::GenerateBuilderParsingCodeFromPacked(
 io::Printer* printer) const {
 ReportUnexpectedPackedFieldsCall(printer);
 }
diff --git a/src/google/protobuf/compiler/java/java_field.h b/src/google/protobuf/compiler/java/java_field.h
index 9d04dc8..7e0cd77 100644
--- a/src/google/protobuf/compiler/java/java_field.h
+++ b/src/google/protobuf/compiler/java/java_field.h
@@ -76,9 +76,8 @@ class ImmutableFieldGenerator {
 virtual void GenerateBuilderClearCode(io::Printer* printer) const = 0;
 virtual void GenerateMergingCode(io::Printer* printer) const = 0;
 virtual void GenerateBuildingCode(io::Printer* printer) const = 0;
- virtual void GenerateParsingCode(io::Printer* printer) const = 0;
- virtual void GenerateParsingCodeFromPacked(io::Printer* printer) const;
- virtual void GenerateParsingDoneCode(io::Printer* printer) const = 0;
+ virtual void GenerateBuilderParsingCode(io::Printer* printer) const = 0;
+ virtual void GenerateBuilderParsingCodeFromPacked(io::Printer* printer) const;
 virtual void GenerateSerializationCode(io::Printer* printer) const = 0;
 virtual void GenerateSerializedSizeCode(io::Printer* printer) const = 0;
 virtual void GenerateFieldBuilderInitializationCode(
diff --git a/src/google/protobuf/compiler/java/java_map_field.cc b/src/google/protobuf/compiler/java/java_map_field.cc
index 5db199d..1fb8f1e 100644
--- a/src/google/protobuf/compiler/java/java_map_field.cc
+++ b/src/google/protobuf/compiler/java/java_map_field.cc
@@ -138,13 +138,6 @@ void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex,
 descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
 (*variables)["on_changed"] = "onChanged();";
 
- // For repeated fields, one bit is used for whether the array is immutable
- // in the parsing constructor.
- (*variables)["get_mutable_bit_parser"] =
- GenerateGetBitMutableLocal(builderBitIndex);
- (*variables)["set_mutable_bit_parser"] =
- GenerateSetBitMutableLocal(builderBitIndex);
-
 (*variables)["default_entry"] =
 (*variables)["capitalized_name"] + "DefaultEntryHolder.defaultEntry";
 (*variables)["map_field_parameter"] = (*variables)["default_entry"];
@@ -681,27 +674,19 @@ void ImmutableMapFieldGenerator::GenerateBuildingCode(
 "result.$name$_.makeImmutable();\n");
 }
 
-void ImmutableMapFieldGenerator::GenerateParsingCode(
+void ImmutableMapFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
- printer->Print(variables_,
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = com.google.protobuf.MapField.newMapField(\n"
- " $map_field_parameter$);\n"
- " $set_mutable_bit_parser$;\n"
- "}\n");
 if (!SupportUnknownEnumValue(descriptor_->file()) &&
 GetJavaType(ValueField(descriptor_)) == JAVATYPE_ENUM) {
 printer->Print(
 variables_,
 "com.google.protobuf.ByteString bytes = input.readBytes();\n"
 "com.google.protobuf.MapEntry<$type_parameters$>\n"
- "$name$__ = $default_entry$.getParserForType().parseFrom(bytes);\n");
- printer->Print(
- variables_,
+ "$name$__ = $default_entry$.getParserForType().parseFrom(bytes);\n"
 "if ($value_enum_type$.forNumber($name$__.getValue()) == null) {\n"
- " unknownFields.mergeLengthDelimitedField($number$, bytes);\n"
+ " mergeUnknownLengthDelimitedField($number$, bytes);\n"
 "} else {\n"
- " $name$_.getMutableMap().put(\n"
+ " internalGetMutable$capitalized_name$().getMutableMap().put(\n"
 " $name$__.getKey(), $name$__.getValue());\n"
 "}\n");
 } else {
@@ -710,16 +695,11 @@ void ImmutableMapFieldGenerator::GenerateParsingCode(
 "com.google.protobuf.MapEntry<$type_parameters$>\n"
 "$name$__ = input.readMessage(\n"
 " $default_entry$.getParserForType(), extensionRegistry);\n"
- "$name$_.getMutableMap().put(\n"
+ "internalGetMutable$capitalized_name$().getMutableMap().put(\n"
 " $name$__.getKey(), $name$__.getValue());\n");
 }
 }
 
-void ImmutableMapFieldGenerator::GenerateParsingDoneCode(
- io::Printer* printer) const {
- // Nothing to do here.
-}
-
 void ImmutableMapFieldGenerator::GenerateSerializationCode(
 io::Printer* printer) const {
 printer->Print(variables_,
diff --git a/src/google/protobuf/compiler/java/java_map_field.h b/src/google/protobuf/compiler/java/java_map_field.h
index 2ff1f76..4e46222 100644
--- a/src/google/protobuf/compiler/java/java_map_field.h
+++ b/src/google/protobuf/compiler/java/java_map_field.h
@@ -46,23 +46,23 @@ class ImmutableMapFieldGenerator : public ImmutableFieldGenerator {
 ~ImmutableMapFieldGenerator();
 
 // implements ImmutableFieldGenerator ---------------------------------------
- int GetNumBitsForMessage() const;
- int GetNumBitsForBuilder() const;
- void GenerateInterfaceMembers(io::Printer* printer) const;
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
+ int GetNumBitsForMessage() const override;
+ int GetNumBitsForBuilder() const override;
+ void GenerateInterfaceMembers(io::Printer* printer) const override;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateInitializationCode(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
+ 
 std::string GetBoxedType() const;
 
 private:
diff --git a/src/google/protobuf/compiler/java/java_message.cc b/src/google/protobuf/compiler/java/java_message.cc
index 6623595..43c325a 100644
--- a/src/google/protobuf/compiler/java/java_message.cc
+++ b/src/google/protobuf/compiler/java/java_message.cc
@@ -51,6 +51,7 @@
 #include <google/protobuf/descriptor.pb.h>
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/io/printer.h>
+#include <google/protobuf/descriptor.h>
 #include <google/protobuf/wire_format.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/substitute.h>
@@ -367,6 +368,7 @@ void ImmutableMessageGenerator::Generate(io::Printer* printer) {
 "}\n"
 "\n");
 
+ // TODO(b/248149118): Remove this superfluous override.
 printer->Print(
 "@java.lang.Override\n"
 "public final com.google.protobuf.UnknownFieldSet\n"
@@ -374,10 +376,6 @@ void ImmutableMessageGenerator::Generate(io::Printer* printer) {
 " return this.unknownFields;\n"
 "}\n");
 
- if (context_->HasGeneratedMethods(descriptor_)) {
- GenerateParsingConstructor(printer);
- }
-
 GenerateDescriptorMethods(printer);
 
 // Nested types
@@ -624,9 +622,9 @@ void ImmutableMessageGenerator::GenerateMessageSerializationMethods(
 }
 
 if (descriptor_->options().message_set_wire_format()) {
- printer->Print("unknownFields.writeAsMessageSetTo(output);\n");
+ printer->Print("getUnknownFields().writeAsMessageSetTo(output);\n");
 } else {
- printer->Print("unknownFields.writeTo(output);\n");
+ printer->Print("getUnknownFields().writeTo(output);\n");
 }
 
 printer->Outdent();
@@ -655,9 +653,10 @@ void ImmutableMessageGenerator::GenerateMessageSerializationMethods(
 }
 
 if (descriptor_->options().message_set_wire_format()) {
- printer->Print("size += unknownFields.getSerializedSizeAsMessageSet();\n");
+ printer->Print(
+ "size += getUnknownFields().getSerializedSizeAsMessageSet();\n");
 } else {
- printer->Print("size += unknownFields.getSerializedSize();\n");
+ printer->Print("size += getUnknownFields().getSerializedSize();\n");
 }
 
 printer->Print(
@@ -1054,7 +1053,8 @@ void ImmutableMessageGenerator::GenerateEqualsAndHashCode(
 // false for non-canonical ordering when running in LITE_RUNTIME but it's
 // the best we can do.
 printer->Print(
- "if (!unknownFields.equals(other.unknownFields)) return false;\n");
+ "if (!getUnknownFields().equals(other.getUnknownFields())) return "
+ "false;\n");
 if (descriptor_->extension_range_count() > 0) {
 printer->Print(
 "if (!getExtensionFields().equals(other.getExtensionFields()))\n"
@@ -1128,7 +1128,7 @@ void ImmutableMessageGenerator::GenerateEqualsAndHashCode(
 printer->Print("hash = hashFields(hash, getExtensionFields());\n");
 }
 
- printer->Print("hash = (29 * hash) + unknownFields.hashCode();\n");
+ printer->Print("hash = (29 * hash) + getUnknownFields().hashCode();\n");
 printer->Print(
 "memoizedHashCode = hash;\n"
 "return hash;\n");
@@ -1153,186 +1153,33 @@ void ImmutableMessageGenerator::GenerateExtensionRegistrationCode(
 }
 }
 
-// ===================================================================
-void ImmutableMessageGenerator::GenerateParsingConstructor(
- io::Printer* printer) {
- std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
- SortFieldsByNumber(descriptor_));
-
- printer->Print(
- "private $classname$(\n"
- " com.google.protobuf.CodedInputStream input,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n",
- "classname", descriptor_->name());
- printer->Indent();
-
- // Initialize all fields to default.
- printer->Print(
- "this();\n"
- "if (extensionRegistry == null) {\n"
- " throw new java.lang.NullPointerException();\n"
- "}\n");
-
- // Use builder bits to track mutable repeated fields.
- int totalBuilderBits = 0;
- for (int i = 0; i < descriptor_->field_count(); i++) {
- const ImmutableFieldGenerator& field =
- field_generators_.get(descriptor_->field(i));
- totalBuilderBits += field.GetNumBitsForBuilder();
- }
- int totalBuilderInts = (totalBuilderBits + 31) / 32;
- for (int i = 0; i < totalBuilderInts; i++) {
- printer->Print("int mutable_$bit_field_name$ = 0;\n", "bit_field_name",
- GetBitFieldName(i));
- }
-
- printer->Print(
- "com.google.protobuf.UnknownFieldSet.Builder unknownFields =\n"
- " com.google.protobuf.UnknownFieldSet.newBuilder();\n");
-
- printer->Print("try {\n");
- printer->Indent();
-
- printer->Print(
- "boolean done = false;\n"
- "while (!done) {\n");
- printer->Indent();
-
- printer->Print(
- "int tag = input.readTag();\n"
- "switch (tag) {\n");
- printer->Indent();
-
- printer->Print(
- "case 0:\n" // zero signals EOF / limit reached
- " done = true;\n"
- " break;\n");
-
- for (int i = 0; i < descriptor_->field_count(); i++) {
- const FieldDescriptor* field = sorted_fields[i];
- uint32 tag = WireFormatLite::MakeTag(
- field->number(), WireFormat::WireTypeForFieldType(field->type()));
-
- printer->Print("case $tag$: {\n", "tag",
- StrCat(static_cast<int32>(tag)));
- printer->Indent();
-
- field_generators_.get(field).GenerateParsingCode(printer);
-
- printer->Outdent();
- printer->Print(
- " break;\n"
- "}\n");
-
- if (field->is_packable()) {
- // To make packed = true wire compatible, we generate parsing code from a
- // packed version of this field regardless of field->options().packed().
- uint32 packed_tag = WireFormatLite::MakeTag(
- field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
- printer->Print("case $tag$: {\n", "tag",
- StrCat(static_cast<int32>(packed_tag)));
- printer->Indent();
-
- field_generators_.get(field).GenerateParsingCodeFromPacked(printer);
-
- printer->Outdent();
- printer->Print(
- " break;\n"
- "}\n");
- }
- }
-
- printer->Print(
- "default: {\n"
- " if (!parseUnknownField(\n"
- " input, unknownFields, extensionRegistry, tag)) {\n"
- " done = true;\n" // it's an endgroup tag
- " }\n"
- " break;\n"
- "}\n");
-
- printer->Outdent();
- printer->Outdent();
- printer->Print(
- " }\n" // switch (tag)
- "}\n"); // while (!done)
-
- printer->Outdent();
- printer->Print(
- "} catch (com.google.protobuf.InvalidProtocolBufferException e) {\n"
- " throw e.setUnfinishedMessage(this);\n"
- "} catch (java.io.IOException e) {\n"
- " throw new com.google.protobuf.InvalidProtocolBufferException(\n"
- " e).setUnfinishedMessage(this);\n"
- "} finally {\n");
- printer->Indent();
-
- // Make repeated field list immutable.
- for (int i = 0; i < descriptor_->field_count(); i++) {
- const FieldDescriptor* field = sorted_fields[i];
- field_generators_.get(field).GenerateParsingDoneCode(printer);
- }
-
- // Make unknown fields immutable.
- printer->Print("this.unknownFields = unknownFields.build();\n");
-
- // Make extensions immutable.
- printer->Print("makeExtensionsImmutable();\n");
-
- printer->Outdent();
- printer->Outdent();
- printer->Print(
- " }\n" // finally
- "}\n");
-}
-
 // ===================================================================
 void ImmutableMessageGenerator::GenerateParser(io::Printer* printer) {
 printer->Print(
 "$visibility$ static final com.google.protobuf.Parser<$classname$>\n"
- " PARSER = new com.google.protobuf.AbstractParser<$classname$>() {\n",
- "visibility",
- ExposePublicParser(descriptor_->file()) ? "@java.lang.Deprecated public"
- : "private",
- "classname", descriptor_->name());
- printer->Indent();
- printer->Print(
- "@java.lang.Override\n"
- "public $classname$ parsePartialFrom(\n"
- " com.google.protobuf.CodedInputStream input,\n"
- " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
- " throws com.google.protobuf.InvalidProtocolBufferException {\n",
- "classname", descriptor_->name());
- if (context_->HasGeneratedMethods(descriptor_)) {
- printer->Print(" return new $classname$(input, extensionRegistry);\n",
- "classname", descriptor_->name());
- } else {
- // When parsing constructor isn't generated, use builder to parse
- // messages. Note, will fallback to use reflection based mergeFieldFrom()
- // in AbstractMessage.Builder.
- printer->Indent();
- printer->Print(
- "Builder builder = newBuilder();\n"
- "try {\n"
- " builder.mergeFrom(input, extensionRegistry);\n"
- "} catch (com.google.protobuf.InvalidProtocolBufferException e) {\n"
- " throw e.setUnfinishedMessage(builder.buildPartial());\n"
- "} catch (java.io.IOException e) {\n"
- " throw new com.google.protobuf.InvalidProtocolBufferException(\n"
- " e.getMessage()).setUnfinishedMessage(\n"
- " builder.buildPartial());\n"
- "}\n"
- "return builder.buildPartial();\n");
- printer->Outdent();
- }
- printer->Print("}\n");
- printer->Outdent();
- printer->Print(
+ " PARSER = new com.google.protobuf.AbstractParser<$classname$>() {\n"
+ " @java.lang.Override\n"
+ " public $classname$ parsePartialFrom(\n"
+ " com.google.protobuf.CodedInputStream input,\n"
+ " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
+ " throws com.google.protobuf.InvalidProtocolBufferException {\n"
+ " Builder builder = newBuilder();\n"
+ " try {\n"
+ " builder.mergeFrom(input, extensionRegistry);\n"
+ " } catch (com.google.protobuf.InvalidProtocolBufferException e) {\n"
+ " throw e.setUnfinishedMessage(builder.buildPartial());\n"
+ " } catch (com.google.protobuf.UninitializedMessageException e) {\n"
+ " throw "
+ "e.asInvalidProtocolBufferException().setUnfinishedMessage(builder."
+ "buildPartial());\n"
+ " } catch (java.io.IOException e) {\n"
+ " throw new com.google.protobuf.InvalidProtocolBufferException(e)\n"
+ " .setUnfinishedMessage(builder.buildPartial());\n"
+ " }\n"
+ " return builder.buildPartial();\n"
+ " }\n"
 "};\n"
- "\n");
-
- printer->Print(
+ "\n"
 "public static com.google.protobuf.Parser<$classname$> parser() {\n"
 " return PARSER;\n"
 "}\n"
@@ -1342,6 +1189,9 @@ void ImmutableMessageGenerator::GenerateParser(io::Printer* printer) {
 " return PARSER;\n"
 "}\n"
 "\n",
+ "visibility",
+ ExposePublicParser(descriptor_->file()) ? "@java.lang.Deprecated public"
+ : "private",
 "classname", descriptor_->name());
 }
 
diff --git a/src/google/protobuf/compiler/java/java_message_builder.cc b/src/google/protobuf/compiler/java/java_message_builder.cc
index 320852b..24ea648 100644
--- a/src/google/protobuf/compiler/java/java_message_builder.cc
+++ b/src/google/protobuf/compiler/java/java_message_builder.cc
@@ -58,6 +58,9 @@ namespace protobuf {
 namespace compiler {
 namespace java {
 
+using internal::WireFormat;
+using internal::WireFormatLite;
+
 namespace {
 std::string MapValueImmutableClassdName(const Descriptor* descriptor,
 ClassNameResolver* name_resolver) {
@@ -285,43 +288,63 @@ void MessageBuilderGenerator::GenerateDescriptorMethods(io::Printer* printer) {
 
 void MessageBuilderGenerator::GenerateCommonBuilderMethods(
 io::Printer* printer) {
+ // Decide if we really need to have the "maybeForceBuilderInitialization()"
+ // method.
+ // TODO(b/249158148): Remove the need for this entirely
+ bool need_maybe_force_builder_init = false;
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ if (descriptor_->field(i)->message_type() != nullptr &&
+ !IsRealOneof(descriptor_->field(i)) &&
+ HasHasbit(descriptor_->field(i))) {
+ need_maybe_force_builder_init = true;
+ break;
+ }
+ }
+
+ const char* force_builder_init = need_maybe_force_builder_init
+ ? " maybeForceBuilderInitialization();"
+ : "";
+
 printer->Print(
 "// Construct using $classname$.newBuilder()\n"
 "private Builder() {\n"
- " maybeForceBuilderInitialization();\n"
+ "$force_builder_init$\n"
 "}\n"
 "\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "classname", name_resolver_->GetImmutableClassName(descriptor_),
+ "force_builder_init", force_builder_init);
 
 printer->Print(
 "private Builder(\n"
 " com.google.protobuf.GeneratedMessage$ver$.BuilderParent parent) {\n"
 " super(parent);\n"
- " maybeForceBuilderInitialization();\n"
+ "$force_builder_init$\n"
 "}\n",
 "classname", name_resolver_->GetImmutableClassName(descriptor_), "ver",
- GeneratedCodeVersionSuffix());
+ GeneratedCodeVersionSuffix(), "force_builder_init", force_builder_init);
 
- printer->Print(
- "private void maybeForceBuilderInitialization() {\n"
- " if (com.google.protobuf.GeneratedMessage$ver$\n"
- " .alwaysUseFieldBuilders) {\n",
- "ver", GeneratedCodeVersionSuffix());
+ if (need_maybe_force_builder_init) {
+ printer->Print(
+ "private void maybeForceBuilderInitialization() {\n"
+ " if (com.google.protobuf.GeneratedMessage$ver$\n"
+ " .alwaysUseFieldBuilders) {\n",
+ "ver", GeneratedCodeVersionSuffix());
 
- printer->Indent();
- printer->Indent();
- for (int i = 0; i < descriptor_->field_count(); i++) {
- if (!IsRealOneof(descriptor_->field(i))) {
- field_generators_.get(descriptor_->field(i))
- .GenerateFieldBuilderInitializationCode(printer);
+ printer->Indent();
+ printer->Indent();
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ if (!IsRealOneof(descriptor_->field(i))) {
+ field_generators_.get(descriptor_->field(i))
+ .GenerateFieldBuilderInitializationCode(printer);
+ }
 }
- }
- printer->Outdent();
- printer->Outdent();
+ printer->Outdent();
+ printer->Outdent();
 
- printer->Print(
- " }\n"
- "}\n");
+ printer->Print(
+ " }\n"
+ "}\n");
+ }
 
 printer->Print(
 "@java.lang.Override\n"
@@ -331,10 +354,8 @@ void MessageBuilderGenerator::GenerateCommonBuilderMethods(
 printer->Indent();
 
 for (int i = 0; i < descriptor_->field_count(); i++) {
- if (!IsRealOneof(descriptor_->field(i))) {
- field_generators_.get(descriptor_->field(i))
- .GenerateBuilderClearCode(printer);
- }
+ field_generators_.get(descriptor_->field(i))
+ .GenerateBuilderClearCode(printer);
 }
 
 for (auto oneof : oneofs_) {
@@ -575,7 +596,7 @@ void MessageBuilderGenerator::GenerateCommonBuilderMethods(
 printer->Print(" this.mergeExtensionFields(other);\n");
 }
 
- printer->Print(" this.mergeUnknownFields(other.unknownFields);\n");
+ printer->Print(" this.mergeUnknownFields(other.getUnknownFields());\n");
 
 printer->Print(" onChanged();\n");
 
@@ -596,20 +617,92 @@ void MessageBuilderGenerator::GenerateBuilderParsingMethods(
 " com.google.protobuf.CodedInputStream input,\n"
 " com.google.protobuf.ExtensionRegistryLite extensionRegistry)\n"
 " throws java.io.IOException {\n"
- " $classname$ parsedMessage = null;\n"
+ " if (extensionRegistry == null) {\n"
+ " throw new java.lang.NullPointerException();\n"
+ " }\n"
 " try {\n"
- " parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);\n"
+ " boolean done = false;\n"
+ " while (!done) {\n"
+ " int tag = input.readTag();\n"
+ " switch (tag) {\n"
+ " case 0:\n" // zero signals EOF / limit reached
+ " done = true;\n"
+ " break;\n");
+ printer->Indent(); // method
+ printer->Indent(); // try
+ printer->Indent(); // while
+ printer->Indent(); // switch
+ GenerateBuilderFieldParsingCases(printer);
+ printer->Outdent(); // switch
+ printer->Outdent(); // while
+ printer->Outdent(); // try
+ printer->Outdent(); // method
+ printer->Print(
+ " default: {\n"
+ " if (!super.parseUnknownField(input, extensionRegistry, tag)) "
+ "{\n"
+ " done = true; // was an endgroup tag\n"
+ " }\n"
+ " break;\n"
+ " } // default:\n"
+ " } // switch (tag)\n"
+ " } // while (!done)\n"
 " } catch (com.google.protobuf.InvalidProtocolBufferException e) {\n"
- " parsedMessage = ($classname$) e.getUnfinishedMessage();\n"
 " throw e.unwrapIOException();\n"
 " } finally {\n"
- " if (parsedMessage != null) {\n"
- " mergeFrom(parsedMessage);\n"
- " }\n"
- " }\n"
+ " onChanged();\n"
+ " } // finally\n"
 " return this;\n"
- "}\n",
- "classname", name_resolver_->GetImmutableClassName(descriptor_));
+ "}\n");
+}
+
+void MessageBuilderGenerator::GenerateBuilderFieldParsingCases(
+ io::Printer* printer) {
+ std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
+ SortFieldsByNumber(descriptor_));
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ const FieldDescriptor* field = sorted_fields[i];
+ GenerateBuilderFieldParsingCase(printer, field);
+ if (field->is_packable()) {
+ GenerateBuilderPackedFieldParsingCase(printer, field);
+ }
+ }
+}
+
+void MessageBuilderGenerator::GenerateBuilderFieldParsingCase(
+ io::Printer* printer, const FieldDescriptor* field) {
+ uint32_t tag = WireFormatLite::MakeTag(
+ field->number(), WireFormat::WireTypeForFieldType(field->type()));
+ std::string tagString = StrCat(static_cast<int32_t>(tag));
+ printer->Print("case $tag$: {\n", "tag", tagString);
+ printer->Indent();
+
+ field_generators_.get(field).GenerateBuilderParsingCode(printer);
+
+ printer->Outdent();
+ printer->Print(
+ " break;\n"
+ "} // case $tag$\n",
+ "tag", tagString);
+}
+
+void MessageBuilderGenerator::GenerateBuilderPackedFieldParsingCase(
+ io::Printer* printer, const FieldDescriptor* field) {
+ // To make packed = true wire compatible, we generate parsing code from a
+ // packed version of this field regardless of field->options().packed().
+ uint32_t tag = WireFormatLite::MakeTag(
+ field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
+ std::string tagString = StrCat(static_cast<int32_t>(tag));
+ printer->Print("case $tag$: {\n", "tag", tagString);
+ printer->Indent();
+
+ field_generators_.get(field).GenerateBuilderParsingCodeFromPacked(printer);
+
+ printer->Outdent();
+ printer->Print(
+ " break;\n"
+ "} // case $tag$\n",
+ "tag", tagString);
 }
 
 // ===================================================================
diff --git a/src/google/protobuf/compiler/java/java_message_builder.h b/src/google/protobuf/compiler/java/java_message_builder.h
index fcd73b3..96f289a 100644
--- a/src/google/protobuf/compiler/java/java_message_builder.h
+++ b/src/google/protobuf/compiler/java/java_message_builder.h
@@ -70,6 +70,11 @@ class MessageBuilderGenerator {
 void GenerateCommonBuilderMethods(io::Printer* printer);
 void GenerateDescriptorMethods(io::Printer* printer);
 void GenerateBuilderParsingMethods(io::Printer* printer);
+ void GenerateBuilderFieldParsingCases(io::Printer* printer);
+ void GenerateBuilderFieldParsingCase(io::Printer* printer,
+ const FieldDescriptor* field);
+ void GenerateBuilderPackedFieldParsingCase(io::Printer* printer,
+ const FieldDescriptor* field);
 void GenerateIsInitialized(io::Printer* printer);
 
 const Descriptor* descriptor_;
diff --git a/src/google/protobuf/compiler/java/java_message_field.cc b/src/google/protobuf/compiler/java/java_message_field.cc
index 96c0c11..a1db832 100644
--- a/src/google/protobuf/compiler/java/java_message_field.cc
+++ b/src/google/protobuf/compiler/java/java_message_field.cc
@@ -102,13 +102,6 @@ void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex,
 (*variables)["set_mutable_bit_builder"] = GenerateSetBit(builderBitIndex);
 (*variables)["clear_mutable_bit_builder"] = GenerateClearBit(builderBitIndex);
 
- // For repeated fields, one bit is used for whether the array is immutable
- // in the parsing constructor.
- (*variables)["get_mutable_bit_parser"] =
- GenerateGetBitMutableLocal(builderBitIndex);
- (*variables)["set_mutable_bit_parser"] =
- GenerateSetBitMutableLocal(builderBitIndex);
-
 (*variables)["get_has_field_bit_from_local"] =
 GenerateGetBitFromLocal(builderBitIndex);
 (*variables)["set_has_field_bit_to_local"] =
@@ -456,35 +449,21 @@ void ImmutableMessageFieldGenerator::GenerateBuildingCode(
 }
 }
 
-void ImmutableMessageFieldGenerator::GenerateParsingCode(
+void ImmutableMessageFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
- printer->Print(variables_,
- "$type$.Builder subBuilder = null;\n"
- "if ($is_field_present_message$) {\n"
- " subBuilder = $name$_.toBuilder();\n"
- "}\n");
-
 if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
 printer->Print(variables_,
- "$name$_ = input.readGroup($number$, $type$.$get_parser$,\n"
- " extensionRegistry);\n");
+ "input.readGroup($number$,\n"
+ " get$capitalized_name$FieldBuilder().getBuilder(),\n"
+ " extensionRegistry);\n"
+ "$set_has_field_bit_builder$\n");
 } else {
 printer->Print(variables_,
- "$name$_ = input.readMessage($type$.$get_parser$, "
- "extensionRegistry);\n");
+ "input.readMessage(\n"
+ " get$capitalized_name$FieldBuilder().getBuilder(),\n"
+ " extensionRegistry);\n"
+ "$set_has_field_bit_builder$\n");
 }
-
- printer->Print(variables_,
- "if (subBuilder != null) {\n"
- " subBuilder.mergeFrom($name$_);\n"
- " $name$_ = subBuilder.buildPartial();\n"
- "}\n"
- "$set_has_field_bit_message$\n");
-}
-
-void ImmutableMessageFieldGenerator::GenerateParsingDoneCode(
- io::Printer* printer) const {
- // noop for messages.
 }
 
 void ImmutableMessageFieldGenerator::GenerateSerializationCode(
@@ -736,6 +715,15 @@ void ImmutableMessageOneofFieldGenerator::GenerateBuilderMembers(
 printer->Annotate("{", "}", descriptor_);
 }
 
+void ImmutableMessageOneofFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
+ // Make sure the builder gets cleared.
+ printer->Print(variables_,
+ "if ($name$Builder_ != null) {\n"
+ " $name$Builder_.clear();\n"
+ "}\n");
+}
+
 void ImmutableMessageOneofFieldGenerator::GenerateBuildingCode(
 io::Printer* printer) const {
 printer->Print(variables_, "if ($has_oneof_case_message$) {\n");
@@ -756,32 +744,21 @@ void ImmutableMessageOneofFieldGenerator::GenerateMergingCode(
 "merge$capitalized_name$(other.get$capitalized_name$());\n");
 }
 
-void ImmutableMessageOneofFieldGenerator::GenerateParsingCode(
+void ImmutableMessageOneofFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
- printer->Print(variables_,
- "$type$.Builder subBuilder = null;\n"
- "if ($has_oneof_case_message$) {\n"
- " subBuilder = (($type$) $oneof_name$_).toBuilder();\n"
- "}\n");
-
 if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
- printer->Print(
- variables_,
- "$oneof_name$_ = input.readGroup($number$, $type$.$get_parser$,\n"
- " extensionRegistry);\n");
+ printer->Print(variables_,
+ "input.readGroup($number$,\n"
+ " get$capitalized_name$FieldBuilder().getBuilder(),\n"
+ " extensionRegistry);\n"
+ "$set_oneof_case_message$;\n");
 } else {
- printer->Print(
- variables_,
- "$oneof_name$_ =\n"
- " input.readMessage($type$.$get_parser$, extensionRegistry);\n");
+ printer->Print(variables_,
+ "input.readMessage(\n"
+ " get$capitalized_name$FieldBuilder().getBuilder(),\n"
+ " extensionRegistry);\n"
+ "$set_oneof_case_message$;\n");
 }
-
- printer->Print(variables_,
- "if (subBuilder != null) {\n"
- " subBuilder.mergeFrom(($type$) $oneof_name$_);\n"
- " $oneof_name$_ = subBuilder.buildPartial();\n"
- "}\n");
- printer->Print(variables_, "$set_oneof_case_message$;\n");
 }
 
 void ImmutableMessageOneofFieldGenerator::GenerateSerializationCode(
@@ -1232,10 +1209,12 @@ void RepeatedImmutableMessageFieldGenerator::GenerateInitializationCode(
 void RepeatedImmutableMessageFieldGenerator::GenerateBuilderClearCode(
 io::Printer* printer) const {
 PrintNestedBuilderCondition(printer,
- "$name$_ = java.util.Collections.emptyList();\n"
- "$clear_mutable_bit_builder$;\n",
+ "$name$_ = java.util.Collections.emptyList();\n",
 
+ "$name$_ = null;\n"
 "$name$Builder_.clear();\n");
+
+ printer->Print(variables_, "$clear_mutable_bit_builder$;\n");
 }
 
 void RepeatedImmutableMessageFieldGenerator::GenerateMergingCode(
@@ -1290,34 +1269,25 @@ void RepeatedImmutableMessageFieldGenerator::GenerateBuildingCode(
 "result.$name$_ = $name$Builder_.build();\n");
 }
 
-void RepeatedImmutableMessageFieldGenerator::GenerateParsingCode(
+void RepeatedImmutableMessageFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
- printer->Print(variables_,
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = new java.util.ArrayList<$type$>();\n"
- " $set_mutable_bit_parser$;\n"
- "}\n");
-
 if (GetType(descriptor_) == FieldDescriptor::TYPE_GROUP) {
- printer->Print(
- variables_,
- "$name$_.add(input.readGroup($number$, $type$.$get_parser$,\n"
- " extensionRegistry));\n");
+ printer->Print(variables_,
+ "$type$ m =\n"
+ " input.readGroup($number$,\n"
+ " $type$.$get_parser$,\n"
+ " extensionRegistry);\n");
 } else {
- printer->Print(
- variables_,
- "$name$_.add(\n"
- " input.readMessage($type$.$get_parser$, extensionRegistry));\n");
+ printer->Print(variables_,
+ "$type$ m =\n"
+ " input.readMessage(\n"
+ " $type$.$get_parser$,\n"
+ " extensionRegistry);\n");
 }
-}
-
-void RepeatedImmutableMessageFieldGenerator::GenerateParsingDoneCode(
- io::Printer* printer) const {
- printer->Print(
- variables_,
- "if ($get_mutable_bit_parser$) {\n"
- " $name$_ = java.util.Collections.unmodifiableList($name$_);\n"
- "}\n");
+ PrintNestedBuilderCondition(printer,
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.add(m);\n",
+ "$name$Builder_.addMessage(m);\n");
 }
 
 void RepeatedImmutableMessageFieldGenerator::GenerateSerializationCode(
diff --git a/src/google/protobuf/compiler/java/java_message_field.h b/src/google/protobuf/compiler/java/java_message_field.h
index 36fa492..07e0256 100644
--- a/src/google/protobuf/compiler/java/java_message_field.h
+++ b/src/google/protobuf/compiler/java/java_message_field.h
@@ -65,24 +65,24 @@ class ImmutableMessageFieldGenerator : public ImmutableFieldGenerator {
 
 // implements ImmutableFieldGenerator
 // ---------------------------------------
- int GetNumBitsForMessage() const;
- int GetNumBitsForBuilder() const;
- void GenerateInterfaceMembers(io::Printer* printer) const;
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
- std::string GetBoxedType() const;
+ int GetNumBitsForMessage() const override;
+ int GetNumBitsForBuilder() const override;
+ void GenerateInterfaceMembers(io::Printer* printer) const override;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateInitializationCode(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
+
+ std::string GetBoxedType() const override;
 
 protected:
 const FieldDescriptor* descriptor_;
@@ -110,13 +110,14 @@ class ImmutableMessageOneofFieldGenerator
 Context* context);
 ~ImmutableMessageOneofFieldGenerator();
 
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
 
 private:
 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImmutableMessageOneofFieldGenerator);
@@ -130,24 +131,24 @@ class RepeatedImmutableMessageFieldGenerator : public ImmutableFieldGenerator {
 ~RepeatedImmutableMessageFieldGenerator();
 
 // implements ImmutableFieldGenerator ---------------------------------------
- int GetNumBitsForMessage() const;
- int GetNumBitsForBuilder() const;
- void GenerateInterfaceMembers(io::Printer* printer) const;
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
- std::string GetBoxedType() const;
+ int GetNumBitsForMessage() const override;
+ int GetNumBitsForBuilder() const override;
+ void GenerateInterfaceMembers(io::Printer* printer) const override;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateInitializationCode(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
+
+ std::string GetBoxedType() const override;
 
 protected:
 const FieldDescriptor* descriptor_;
diff --git a/src/google/protobuf/compiler/java/java_primitive_field.cc b/src/google/protobuf/compiler/java/java_primitive_field.cc
index f06e8fb..b562a2a 100644
--- a/src/google/protobuf/compiler/java/java_primitive_field.cc
+++ b/src/google/protobuf/compiler/java/java_primitive_field.cc
@@ -166,13 +166,6 @@ void SetPrimitiveVariables(const FieldDescriptor* descriptor,
 (*variables)["set_mutable_bit_builder"] = GenerateSetBit(builderBitIndex);
 (*variables)["clear_mutable_bit_builder"] = GenerateClearBit(builderBitIndex);
 
- // For repeated fields, one bit is used for whether the array is immutable
- // in the parsing constructor.
- (*variables)["get_mutable_bit_parser"] =
- GenerateGetBitMutableLocal(builderBitIndex);
- (*variables)["set_mutable_bit_parser"] =
- GenerateSetBitMutableLocal(builderBitIndex);
-
 (*variables)["get_has_field_bit_from_local"] =
 GenerateGetBitFromLocal(builderBitIndex);
 (*variables)["set_has_field_bit_to_local"] =
@@ -352,16 +345,11 @@ void ImmutablePrimitiveFieldGenerator::GenerateBuildingCode(
 }
 }
 
-void ImmutablePrimitiveFieldGenerator::GenerateParsingCode(
+void ImmutablePrimitiveFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
 printer->Print(variables_,
- "$set_has_field_bit_message$\n"
- "$name$_ = input.read$capitalized_type$();\n");
-}
-
-void ImmutablePrimitiveFieldGenerator::GenerateParsingDoneCode(
- io::Printer* printer) const {
- // noop for primitives.
+ "$name$_ = input.read$capitalized_type$();\n"
+ "$set_has_field_bit_builder$\n");
 }
 
 void ImmutablePrimitiveFieldGenerator::GenerateSerializationCode(
@@ -570,6 +558,12 @@ void ImmutablePrimitiveOneofFieldGenerator::GenerateBuilderMembers(
 printer->Annotate("{", "}", descriptor_);
 }
 
+void ImmutablePrimitiveOneofFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
+ // No-Op: When a primitive field is in a oneof, clearing the oneof clears that
+ // field.
+}
+
 void ImmutablePrimitiveOneofFieldGenerator::GenerateBuildingCode(
 io::Printer* printer) const {
 printer->Print(variables_,
@@ -584,7 +578,7 @@ void ImmutablePrimitiveOneofFieldGenerator::GenerateMergingCode(
 "set$capitalized_name$(other.get$capitalized_name$());\n");
 }
 
-void ImmutablePrimitiveOneofFieldGenerator::GenerateParsingCode(
+void ImmutablePrimitiveOneofFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
 printer->Print(variables_,
 "$set_oneof_case_message$;\n"
@@ -844,38 +838,24 @@ void RepeatedImmutablePrimitiveFieldGenerator::GenerateBuildingCode(
 "result.$name$_ = $name$_;\n");
 }
 
-void RepeatedImmutablePrimitiveFieldGenerator::GenerateParsingCode(
+void RepeatedImmutablePrimitiveFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
 printer->Print(variables_,
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = $create_list$;\n"
- " $set_mutable_bit_parser$;\n"
- "}\n"
- "$repeated_add$(input.read$capitalized_type$());\n");
+ "$type$ v = input.read$capitalized_type$();\n"
+ "ensure$capitalized_name$IsMutable();\n"
+ "$repeated_add$(v);\n");
 }
 
-void RepeatedImmutablePrimitiveFieldGenerator::GenerateParsingCodeFromPacked(
- io::Printer* printer) const {
- printer->Print(
- variables_,
- "int length = input.readRawVarint32();\n"
- "int limit = input.pushLimit(length);\n"
- "if (!$get_mutable_bit_parser$ && input.getBytesUntilLimit() > 0) {\n"
- " $name$_ = $create_list$;\n"
- " $set_mutable_bit_parser$;\n"
- "}\n"
- "while (input.getBytesUntilLimit() > 0) {\n"
- " $repeated_add$(input.read$capitalized_type$());\n"
- "}\n"
- "input.popLimit(limit);\n");
-}
-
-void RepeatedImmutablePrimitiveFieldGenerator::GenerateParsingDoneCode(
- io::Printer* printer) const {
+void RepeatedImmutablePrimitiveFieldGenerator::
+ GenerateBuilderParsingCodeFromPacked(io::Printer* printer) const {
 printer->Print(variables_,
- "if ($get_mutable_bit_parser$) {\n"
- " $name_make_immutable$; // C\n"
- "}\n");
+ "int length = input.readRawVarint32();\n"
+ "int limit = input.pushLimit(length);\n"
+ "ensure$capitalized_name$IsMutable();\n"
+ "while (input.getBytesUntilLimit() > 0) {\n"
+ " $repeated_add$(input.read$capitalized_type$());\n"
+ "}\n"
+ "input.popLimit(limit);\n");
 }
 
 void RepeatedImmutablePrimitiveFieldGenerator::GenerateSerializationCode(
diff --git a/src/google/protobuf/compiler/java/java_primitive_field.h b/src/google/protobuf/compiler/java/java_primitive_field.h
index db20750..e74044a 100644
--- a/src/google/protobuf/compiler/java/java_primitive_field.h
+++ b/src/google/protobuf/compiler/java/java_primitive_field.h
@@ -65,24 +65,24 @@ class ImmutablePrimitiveFieldGenerator : public ImmutableFieldGenerator {
 
 // implements ImmutableFieldGenerator
 // ---------------------------------------
- int GetNumBitsForMessage() const;
- int GetNumBitsForBuilder() const;
- void GenerateInterfaceMembers(io::Printer* printer) const;
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
- std::string GetBoxedType() const;
+ int GetNumBitsForMessage() const override;
+ int GetNumBitsForBuilder() const override;
+ void GenerateInterfaceMembers(io::Printer* printer) const override;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateInitializationCode(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
+
+ std::string GetBoxedType() const override;
 
 protected:
 const FieldDescriptor* descriptor_;
@@ -101,13 +101,14 @@ class ImmutablePrimitiveOneofFieldGenerator
 int builderBitIndex, Context* context);
 ~ImmutablePrimitiveOneofFieldGenerator();
 
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
 
 private:
 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImmutablePrimitiveOneofFieldGenerator);
@@ -122,25 +123,26 @@ class RepeatedImmutablePrimitiveFieldGenerator
 virtual ~RepeatedImmutablePrimitiveFieldGenerator();
 
 // implements ImmutableFieldGenerator ---------------------------------------
- int GetNumBitsForMessage() const;
- int GetNumBitsForBuilder() const;
- void GenerateInterfaceMembers(io::Printer* printer) const;
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingCodeFromPacked(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
- std::string GetBoxedType() const;
+ int GetNumBitsForMessage() const override;
+ int GetNumBitsForBuilder() const override;
+ void GenerateInterfaceMembers(io::Printer* printer) const override;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateInitializationCode(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCodeFromPacked(
+ io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
+
+ std::string GetBoxedType() const override;
 
 private:
 const FieldDescriptor* descriptor_;
diff --git a/src/google/protobuf/compiler/java/java_string_field.cc b/src/google/protobuf/compiler/java/java_string_field.cc
index 548f898..6edac5e 100644
--- a/src/google/protobuf/compiler/java/java_string_field.cc
+++ b/src/google/protobuf/compiler/java/java_string_field.cc
@@ -118,13 +118,6 @@ void SetPrimitiveVariables(const FieldDescriptor* descriptor,
 (*variables)["set_mutable_bit_builder"] = GenerateSetBit(builderBitIndex);
 (*variables)["clear_mutable_bit_builder"] = GenerateClearBit(builderBitIndex);
 
- // For repeated fields, one bit is used for whether the array is immutable
- // in the parsing constructor.
- (*variables)["get_mutable_bit_parser"] =
- GenerateGetBitMutableLocal(builderBitIndex);
- (*variables)["set_mutable_bit_parser"] =
- GenerateSetBitMutableLocal(builderBitIndex);
-
 (*variables)["get_has_field_bit_from_local"] =
 GenerateGetBitFromLocal(builderBitIndex);
 (*variables)["set_has_field_bit_to_local"] =
@@ -413,26 +406,19 @@ void ImmutableStringFieldGenerator::GenerateBuildingCode(
 printer->Print(variables_, "result.$name$_ = $name$_;\n");
 }
 
-void ImmutableStringFieldGenerator::GenerateParsingCode(
+void ImmutableStringFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
 if (CheckUtf8(descriptor_)) {
 printer->Print(variables_,
- "java.lang.String s = input.readStringRequireUtf8();\n"
- "$set_has_field_bit_message$\n"
- "$name$_ = s;\n");
+ "$name$_ = input.readStringRequireUtf8();\n"
+ "$set_has_field_bit_builder$\n");
 } else {
 printer->Print(variables_,
- "com.google.protobuf.ByteString bs = input.readBytes();\n"
- "$set_has_field_bit_message$\n"
- "$name$_ = bs;\n");
+ "$name$_ = input.readBytes();\n"
+ "$set_has_field_bit_builder$\n");
 }
 }
 
-void ImmutableStringFieldGenerator::GenerateParsingDoneCode(
- io::Printer* printer) const {
- // noop for strings.
-}
-
 void ImmutableStringFieldGenerator::GenerateSerializationCode(
 io::Printer* printer) const {
 printer->Print(variables_,
@@ -661,6 +647,11 @@ void ImmutableStringOneofFieldGenerator::GenerateBuilderMembers(
 "}\n");
 }
 
+void ImmutableStringOneofFieldGenerator::GenerateBuilderClearCode(
+ io::Printer* printer) const {
+ // No-Op: String fields in oneofs are correctly cleared by clearing the oneof
+}
+
 void ImmutableStringOneofFieldGenerator::GenerateMergingCode(
 io::Printer* printer) const {
 // Allow a slight breach of abstraction here in order to avoid forcing
@@ -679,7 +670,7 @@ void ImmutableStringOneofFieldGenerator::GenerateBuildingCode(
 "}\n");
 }
 
-void ImmutableStringOneofFieldGenerator::GenerateParsingCode(
+void ImmutableStringOneofFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
 if (CheckUtf8(descriptor_)) {
 printer->Print(variables_,
@@ -969,35 +960,21 @@ void RepeatedImmutableStringFieldGenerator::GenerateBuildingCode(
 "result.$name$_ = $name$_;\n");
 }
 
-void RepeatedImmutableStringFieldGenerator::GenerateParsingCode(
+void RepeatedImmutableStringFieldGenerator::GenerateBuilderParsingCode(
 io::Printer* printer) const {
 if (CheckUtf8(descriptor_)) {
 printer->Print(variables_,
- "java.lang.String s = input.readStringRequireUtf8();\n");
+ "java.lang.String s = input.readStringRequireUtf8();\n"
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.add(s);\n");
 } else {
 printer->Print(variables_,
- "com.google.protobuf.ByteString bs = input.readBytes();\n");
- }
- printer->Print(variables_,
- "if (!$get_mutable_bit_parser$) {\n"
- " $name$_ = new com.google.protobuf.LazyStringArrayList();\n"
- " $set_mutable_bit_parser$;\n"
- "}\n");
- if (CheckUtf8(descriptor_)) {
- printer->Print(variables_, "$name$_.add(s);\n");
- } else {
- printer->Print(variables_, "$name$_.add(bs);\n");
+ "com.google.protobuf.ByteString bs = input.readBytes();\n"
+ "ensure$capitalized_name$IsMutable();\n"
+ "$name$_.add(bs);\n");
 }
 }
 
-void RepeatedImmutableStringFieldGenerator::GenerateParsingDoneCode(
- io::Printer* printer) const {
- printer->Print(variables_,
- "if ($get_mutable_bit_parser$) {\n"
- " $name$_ = $name$_.getUnmodifiableView();\n"
- "}\n");
-}
-
 void RepeatedImmutableStringFieldGenerator::GenerateSerializationCode(
 io::Printer* printer) const {
 printer->Print(variables_,
diff --git a/src/google/protobuf/compiler/java/java_string_field.h b/src/google/protobuf/compiler/java/java_string_field.h
index 1c00ae8..4aaabfb 100644
--- a/src/google/protobuf/compiler/java/java_string_field.h
+++ b/src/google/protobuf/compiler/java/java_string_field.h
@@ -65,24 +65,24 @@ class ImmutableStringFieldGenerator : public ImmutableFieldGenerator {
 
 // implements ImmutableFieldGenerator
 // ---------------------------------------
- int GetNumBitsForMessage() const;
- int GetNumBitsForBuilder() const;
- void GenerateInterfaceMembers(io::Printer* printer) const;
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
- std::string GetBoxedType() const;
+ int GetNumBitsForMessage() const override;
+ int GetNumBitsForBuilder() const override;
+ void GenerateInterfaceMembers(io::Printer* printer) const override;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateInitializationCode(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
+
+ std::string GetBoxedType() const override;
 
 protected:
 const FieldDescriptor* descriptor_;
@@ -102,13 +102,14 @@ class ImmutableStringOneofFieldGenerator
 ~ImmutableStringOneofFieldGenerator();
 
 private:
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
 
 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImmutableStringOneofFieldGenerator);
 };
@@ -121,24 +122,24 @@ class RepeatedImmutableStringFieldGenerator : public ImmutableFieldGenerator {
 ~RepeatedImmutableStringFieldGenerator();
 
 // implements ImmutableFieldGenerator ---------------------------------------
- int GetNumBitsForMessage() const;
- int GetNumBitsForBuilder() const;
- void GenerateInterfaceMembers(io::Printer* printer) const;
- void GenerateMembers(io::Printer* printer) const;
- void GenerateBuilderMembers(io::Printer* printer) const;
- void GenerateInitializationCode(io::Printer* printer) const;
- void GenerateBuilderClearCode(io::Printer* printer) const;
- void GenerateMergingCode(io::Printer* printer) const;
- void GenerateBuildingCode(io::Printer* printer) const;
- void GenerateParsingCode(io::Printer* printer) const;
- void GenerateParsingDoneCode(io::Printer* printer) const;
- void GenerateSerializationCode(io::Printer* printer) const;
- void GenerateSerializedSizeCode(io::Printer* printer) const;
- void GenerateFieldBuilderInitializationCode(io::Printer* printer) const;
- void GenerateEqualsCode(io::Printer* printer) const;
- void GenerateHashCode(io::Printer* printer) const;
-
- std::string GetBoxedType() const;
+ int GetNumBitsForMessage() const override;
+ int GetNumBitsForBuilder() const override;
+ void GenerateInterfaceMembers(io::Printer* printer) const override;
+ void GenerateMembers(io::Printer* printer) const override;
+ void GenerateBuilderMembers(io::Printer* printer) const override;
+ void GenerateInitializationCode(io::Printer* printer) const override;
+ void GenerateBuilderClearCode(io::Printer* printer) const override;
+ void GenerateMergingCode(io::Printer* printer) const override;
+ void GenerateBuildingCode(io::Printer* printer) const override;
+ void GenerateBuilderParsingCode(io::Printer* printer) const override;
+ void GenerateSerializationCode(io::Printer* printer) const override;
+ void GenerateSerializedSizeCode(io::Printer* printer) const override;
+ void GenerateFieldBuilderInitializationCode(
+ io::Printer* printer) const override;
+ void GenerateEqualsCode(io::Printer* printer) const override;
+ void GenerateHashCode(io::Printer* printer) const override;
+
+ std::string GetBoxedType() const override;
 
 private:
 const FieldDescriptor* descriptor_;
-- 
2.25.1