Allow dart protos to be sent through sendports (and therefore to other isolates) (#452)

Decoded protos in Dart are represented in memory as instances of
`GeneratedMessage` subclasses. The `GeneratedMessage` stores the field
state in a `_FieldSet` and `UnknownFieldSet`.

The `_FieldSet._meta` field points to a `BuilderInfo` object, which
represents the metadata of the proto message.

Sending this reference to `BuilderInfo` makes it hard to send dart
protos to other isolates, because

  a) `BuilderInfo` hangs on to non-static closures, which cannot
      be sent to to other isolates atm

  b) Sending a transitive copy would copy the `BuilderInfo` object (and
     it's transitive closure). That can cause big waste of memory
     since an isolate would have this metadata possibly many times.

To avoid these two issues, this CL does the following:

  * We replace `_FieldSet._meta` with a getter that accesses the
    `BuilderInfo` via the `_FieldSet._message.info_` getter. This getter
    is implemented in `GeneratedMessage` subclasses and reads from a
    static field.

    => We effectively replace a load of the `_meta` field with load +
       interface call + static field load.

  * To avoid performance regressions we avoid accessing the new
    `_FieldSet._meta` getter in the hot decoding loops. Instead we
    obtain this metadata once and pass it down to various methods that
    are part of decoding.

  * For similar reasons, we remove the `PbMap._entryBuilderInfo`
    field - which also refers to a `BuilderInfo`. Instead we obtain the
    neccessary map-specific `BuilderInfo` in the main decoder loop.

This CL has to remove the 2 year long deprecated `PbMap.add()` functiondeprecated.

Author: mkustermann

protobuf/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.0.0-nullsafety.1
+
+* Remove `PbMap.add` method which was deprecated in 0.13.3
+
 ## 2.0.0-nullsafety.0
 
 * Require at least Dart SDK 2.12.0 and support null safety. Use `protoc_plugin`

protobuf/lib/src/protobuf/coded_buffer.dart

@@ -26,18 +26,17 @@ void _writeToCodedBufferWriter(_FieldSet fs, CodedBufferWriter out) {
   }
 }
 
-void _mergeFromCodedBufferReader(
-    _FieldSet fs, CodedBufferReader input, ExtensionRegistry registry) {
+void _mergeFromCodedBufferReader(BuilderInfo meta, _FieldSet fs,
+    CodedBufferReader input, ExtensionRegistry registry) {
   ArgumentError.checkNotNull(registry);
-
   while (true) {
     var tag = input.readTag();
     if (tag == 0) return;
     var wireType = tag & 0x7;
     var tagNumber = tag >> 3;
 
-    var fi = fs._nonExtensionInfo(tagNumber);
-    fi ??= registry.getExtension(fs._messageName, tagNumber);
+    var fi = fs._nonExtensionInfo(meta, tagNumber);
+    fi ??= registry.getExtension(meta.qualifiedMessageName, tagNumber);
 
     if (fi == null || !_wireTypeMatches(fi.type, wireType)) {
       if (!fs._ensureUnknownFields().mergeFieldFromBuffer(tag, input)) {
@@ -51,156 +50,167 @@ void _mergeFromCodedBufferReader(
     fieldType &= ~(PbFieldType._PACKED_BIT | PbFieldType._REQUIRED_BIT);
     switch (fieldType) {
       case PbFieldType._OPTIONAL_BOOL:
-        fs._setFieldUnchecked(fi, input.readBool());
+        fs._setFieldUnchecked(meta, fi, input.readBool());
         break;
       case PbFieldType._OPTIONAL_BYTES:
-        fs._setFieldUnchecked(fi, input.readBytes());
+        fs._setFieldUnchecked(meta, fi, input.readBytes());
         break;
       case PbFieldType._OPTIONAL_STRING:
-        fs._setFieldUnchecked(fi, input.readString());
+        fs._setFieldUnchecked(meta, fi, input.readString());
         break;
       case PbFieldType._OPTIONAL_FLOAT:
-        fs._setFieldUnchecked(fi, input.readFloat());
+        fs._setFieldUnchecked(meta, fi, input.readFloat());
         break;
       case PbFieldType._OPTIONAL_DOUBLE:
-        fs._setFieldUnchecked(fi, input.readDouble());
+        fs._setFieldUnchecked(meta, fi, input.readDouble());
         break;
       case PbFieldType._OPTIONAL_ENUM:
         var rawValue = input.readEnum();
-        var value = fs._meta._decodeEnum(tagNumber, registry, rawValue);
+        var value = meta._decodeEnum(tagNumber, registry, rawValue);
         if (value == null) {
           var unknown = fs._ensureUnknownFields();
           unknown.mergeVarintField(tagNumber, Int64(rawValue));
         } else {
-          fs._setFieldUnchecked(fi, value);
+          fs._setFieldUnchecked(meta, fi, value);
         }
         break;
       case PbFieldType._OPTIONAL_GROUP:
-        var subMessage = fs._meta._makeEmptyMessage(tagNumber, registry);
+        var subMessage = meta._makeEmptyMessage(tagNumber, registry);
         var oldValue = fs._getFieldOrNull(fi);
         if (oldValue != null) {
           subMessage.mergeFromMessage(oldValue);
         }
         input.readGroup(tagNumber, subMessage, registry);
-        fs._setFieldUnchecked(fi, subMessage);
+        fs._setFieldUnchecked(meta, fi, subMessage);
         break;
       case PbFieldType._OPTIONAL_INT32:
-        fs._setFieldUnchecked(fi, input.readInt32());
+        fs._setFieldUnchecked(meta, fi, input.readInt32());
         break;
       case PbFieldType._OPTIONAL_INT64:
-        fs._setFieldUnchecked(fi, input.readInt64());
+        fs._setFieldUnchecked(meta, fi, input.readInt64());
         break;
       case PbFieldType._OPTIONAL_SINT32:
-        fs._setFieldUnchecked(fi, input.readSint32());
+        fs._setFieldUnchecked(meta, fi, input.readSint32());
         break;
       case PbFieldType._OPTIONAL_SINT64:
-        fs._setFieldUnchecked(fi, input.readSint64());
+        fs._setFieldUnchecked(meta, fi, input.readSint64());
         break;
       case PbFieldType._OPTIONAL_UINT32:
-        fs._setFieldUnchecked(fi, input.readUint32());
+        fs._setFieldUnchecked(meta, fi, input.readUint32());
         break;
       case PbFieldType._OPTIONAL_UINT64:
-        fs._setFieldUnchecked(fi, input.readUint64());
+        fs._setFieldUnchecked(meta, fi, input.readUint64());
         break;
       case PbFieldType._OPTIONAL_FIXED32:
-        fs._setFieldUnchecked(fi, input.readFixed32());
+        fs._setFieldUnchecked(meta, fi, input.readFixed32());
         break;
       case PbFieldType._OPTIONAL_FIXED64:
-        fs._setFieldUnchecked(fi, input.readFixed64());
+        fs._setFieldUnchecked(meta, fi, input.readFixed64());
         break;
       case PbFieldType._OPTIONAL_SFIXED32:
-        fs._setFieldUnchecked(fi, input.readSfixed32());
+        fs._setFieldUnchecked(meta, fi, input.readSfixed32());
         break;
       case PbFieldType._OPTIONAL_SFIXED64:
-        fs._setFieldUnchecked(fi, input.readSfixed64());
+        fs._setFieldUnchecked(meta, fi, input.readSfixed64());
         break;
       case PbFieldType._OPTIONAL_MESSAGE:
-        var subMessage = fs._meta._makeEmptyMessage(tagNumber, registry);
+        var subMessage = meta._makeEmptyMessage(tagNumber, registry);
         var oldValue = fs._getFieldOrNull(fi);
         if (oldValue != null) {
           subMessage.mergeFromMessage(oldValue);
         }
         input.readMessage(subMessage, registry);
-        fs._setFieldUnchecked(fi, subMessage);
+        fs._setFieldUnchecked(meta, fi, subMessage);
         break;
       case PbFieldType._REPEATED_BOOL:
-        _readPackable(fs, input, wireType, fi, input.readBool);
+        _readPackable(meta, fs, input, wireType, fi, input.readBool);
         break;
       case PbFieldType._REPEATED_BYTES:
-        fs._ensureRepeatedField(fi).add(input.readBytes());
+        fs._ensureRepeatedField(meta, fi).add(input.readBytes());
         break;
       case PbFieldType._REPEATED_STRING:
-        fs._ensureRepeatedField(fi).add(input.readString());
+        fs._ensureRepeatedField(meta, fi).add(input.readString());
         break;
       case PbFieldType._REPEATED_FLOAT:
-        _readPackable(fs, input, wireType, fi, input.readFloat);
+        _readPackable(meta, fs, input, wireType, fi, input.readFloat);
         break;
       case PbFieldType._REPEATED_DOUBLE:
-        _readPackable(fs, input, wireType, fi, input.readDouble);
+        _readPackable(meta, fs, input, wireType, fi, input.readDouble);
         break;
       case PbFieldType._REPEATED_ENUM:
-        _readPackableToListEnum(fs, input, wireType, fi, tagNumber, registry);
+        _readPackableToListEnum(
+            meta, fs, input, wireType, fi, tagNumber, registry);
         break;
       case PbFieldType._REPEATED_GROUP:
-        var subMessage = fs._meta._makeEmptyMessage(tagNumber, registry);
+        var subMessage = meta._makeEmptyMessage(tagNumber, registry);
         input.readGroup(tagNumber, subMessage, registry);
-        fs._ensureRepeatedField(fi).add(subMessage);
+        fs._ensureRepeatedField(meta, fi).add(subMessage);
         break;
       case PbFieldType._REPEATED_INT32:
-        _readPackable(fs, input, wireType, fi, input.readInt32);
+        _readPackable(meta, fs, input, wireType, fi, input.readInt32);
         break;
       case PbFieldType._REPEATED_INT64:
-        _readPackable(fs, input, wireType, fi, input.readInt64);
+        _readPackable(meta, fs, input, wireType, fi, input.readInt64);
         break;
       case PbFieldType._REPEATED_SINT32:
-        _readPackable(fs, input, wireType, fi, input.readSint32);
+        _readPackable(meta, fs, input, wireType, fi, input.readSint32);
         break;
       case PbFieldType._REPEATED_SINT64:
-        _readPackable(fs, input, wireType, fi, input.readSint64);
+        _readPackable(meta, fs, input, wireType, fi, input.readSint64);
         break;
       case PbFieldType._REPEATED_UINT32:
-        _readPackable(fs, input, wireType, fi, input.readUint32);
+        _readPackable(meta, fs, input, wireType, fi, input.readUint32);
         break;
       case PbFieldType._REPEATED_UINT64:
-        _readPackable(fs, input, wireType, fi, input.readUint64);
+        _readPackable(meta, fs, input, wireType, fi, input.readUint64);
         break;
       case PbFieldType._REPEATED_FIXED32:
-        _readPackable(fs, input, wireType, fi, input.readFixed32);
+        _readPackable(meta, fs, input, wireType, fi, input.readFixed32);
         break;
       case PbFieldType._REPEATED_FIXED64:
-        _readPackable(fs, input, wireType, fi, input.readFixed64);
+        _readPackable(meta, fs, input, wireType, fi, input.readFixed64);
         break;
       case PbFieldType._REPEATED_SFIXED32:
-        _readPackable(fs, input, wireType, fi, input.readSfixed32);
+        _readPackable(meta, fs, input, wireType, fi, input.readSfixed32);
         break;
       case PbFieldType._REPEATED_SFIXED64:
-        _readPackable(fs, input, wireType, fi, input.readSfixed64);
+        _readPackable(meta, fs, input, wireType, fi, input.readSfixed64);
         break;
       case PbFieldType._REPEATED_MESSAGE:
-        var subMessage = fs._meta._makeEmptyMessage(tagNumber, registry);
+        var subMessage = meta._makeEmptyMessage(tagNumber, registry);
         input.readMessage(subMessage, registry);
-        fs._ensureRepeatedField(fi).add(subMessage);
+        fs._ensureRepeatedField(meta, fi).add(subMessage);
         break;
       case PbFieldType._MAP:
-        fs._ensureMapField(fi as MapFieldInfo)._mergeEntry(input, registry);
+        final mapFieldInfo = fi as MapFieldInfo;
+        final mapEntryMeta = mapFieldInfo.mapEntryBuilderInfo;
+        fs
+            ._ensureMapField(meta, mapFieldInfo)
+            ._mergeEntry(mapEntryMeta, input, registry);
         break;
       default:
         throw 'Unknown field type $fieldType';
     }
   }
 }
 
-void _readPackable(_FieldSet fs, CodedBufferReader input, int wireType,
-    FieldInfo fi, Function readFunc) {
+void _readPackable(BuilderInfo meta, _FieldSet fs, CodedBufferReader input,
+    int wireType, FieldInfo fi, Function readFunc) {
   void readToList(List list) => list.add(readFunc());
-  _readPackableToList(fs, input, wireType, fi, readToList);
+  _readPackableToList(meta, fs, input, wireType, fi, readToList);
 }
 
-void _readPackableToListEnum(_FieldSet fs, CodedBufferReader input,
-    int wireType, FieldInfo fi, int tagNumber, ExtensionRegistry registry) {
+void _readPackableToListEnum(
+    BuilderInfo meta,
+    _FieldSet fs,
+    CodedBufferReader input,
+    int wireType,
+    FieldInfo fi,
+    int tagNumber,
+    ExtensionRegistry registry) {
   void readToList(List list) {
     var rawValue = input.readEnum();
-    var value = fs._meta._decodeEnum(tagNumber, registry, rawValue);
+    var value = meta._decodeEnum(tagNumber, registry, rawValue);
     if (value == null) {
       var unknown = fs._ensureUnknownFields();
       unknown.mergeVarintField(tagNumber, Int64(rawValue));
@@ -209,12 +219,12 @@ void _readPackableToListEnum(_FieldSet fs, CodedBufferReader input,
     }
   }
 
-  _readPackableToList(fs, input, wireType, fi, readToList);
+  _readPackableToList(meta, fs, input, wireType, fi, readToList);
 }
 
-void _readPackableToList(_FieldSet fs, CodedBufferReader input, int wireType,
-    FieldInfo fi, Function readToList) {
-  var list = fs._ensureRepeatedField(fi);
+void _readPackableToList(BuilderInfo meta, _FieldSet fs,
+    CodedBufferReader input, int wireType, FieldInfo fi, Function readToList) {
+  var list = fs._ensureRepeatedField(meta, fi);
 
   if (wireType == WIRETYPE_LENGTH_DELIMITED) {
     // Packed.

protobuf/lib/src/protobuf/field_info.dart

@@ -176,8 +176,8 @@ class FieldInfo<T> {
 
   /// Convenience method to thread this FieldInfo's reified type parameter to
   /// _FieldSet._ensureRepeatedField.
-  List<T?> _ensureRepeatedField(_FieldSet fs) {
-    return fs._ensureRepeatedField<T>(this);
+  List<T?> _ensureRepeatedField(BuilderInfo meta, _FieldSet fs) {
+    return fs._ensureRepeatedField<T>(meta, this);
   }
 
   @override
@@ -192,6 +192,9 @@ String _unCamelCase(String name) {
 }
 
 class MapFieldInfo<K, V> extends FieldInfo<PbMap<K, V>?> {
+  static dynamic throwYouShouldNotCallThis() =>
+      throw StateError('You should not call this.');
+
   final int? keyFieldType;
   final int? valueFieldType;
 
@@ -213,8 +216,7 @@ class MapFieldInfo<K, V> extends FieldInfo<PbMap<K, V>?> {
       this.valueCreator,
       {String? protoName})
       : super(name, tagNumber, index, type,
-            defaultOrMaker: () =>
-                PbMap<K, V>(keyFieldType, valueFieldType, mapEntryBuilderInfo),
+            defaultOrMaker: () => throwYouShouldNotCallThis,
             protoName: protoName) {
     ArgumentError.checkNotNull(name, 'name');
     ArgumentError.checkNotNull(tagNumber, 'tagNumber');
@@ -225,8 +227,8 @@ class MapFieldInfo<K, V> extends FieldInfo<PbMap<K, V>?> {
   FieldInfo get valueFieldInfo =>
       mapEntryBuilderInfo.fieldInfo[PbMap._valueFieldNumber]!;
 
-  Map<K, V> _ensureMapField(_FieldSet fs) {
-    return fs._ensureMapField<K, V>(this);
+  Map<K, V> _ensureMapField(BuilderInfo meta, _FieldSet fs) {
+    return fs._ensureMapField<K, V>(meta, this);
   }
 
   Map<K, V> _createMapField(GeneratedMessage m) {