changes for 0.3.9

lib/message_generator.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of protoc;
 
 const String SP = ' ';
 
 class MessageGenerator extends ProtobufContainer {
   // List of Dart language reserved words in names which cannot be used in a
@@ skipping 13 matching lines @@
      'writeToBuffer', 'writeToCodedBufferWriter',
      'mergeFromCodedBufferReader', 'mergeFromBuffer',
      'writeToJson', 'mergeFromJson',
      'writeToJsonMap', 'mergeFromJsonMap',
      'addExtension', 'getExtension', 'setExtension',
      'hasExtension', 'clearExtension',
      'getField', 'setField', 'hasField', 'clearField',
      'extensionsAreInitialized', 'mergeFromMessage', 'mergeUnknownFields',
      '==', 'info_', 'GeneratedMessage', 'Object'];
 
-  // List of names that can't be used in a subclass that implements Map.
-  static final List<String> reservedNamesForMap =
-    ['addAll', 'containsKey', 'containsValue', 'forEach', 'putIfAbsent',
-     'remove', 'isEmpty', 'isNotEmpty', 'keys', 'length', 'values'];
+  // Returns the mixin for this message, or null if none.
+  static String _getMixin(DescriptorProto desc, String defaultValue) {
+    if (!desc.hasOptions()) return defaultValue;
+    if (!desc.options.hasExtension(Dart_options.mixin)) return defaultValue;
 
-  // This should match the extension in dart_options.proto.
-  static const int implementMapOption = 95333044;
-
-  // Returns true if the implement_map option is turned on for the message.
-  static bool _shouldImplementMap(DescriptorProto desc, bool defaultValue) {
-    if (!desc.hasOptions()) return defaultValue;
-
-    var val = desc.options.unknownFields.getField(implementMapOption);
-    if (val == null || val.length != 1) return defaultValue;
-
-    return val.values[0] == 1;
+    String name = desc.options.getExtension(Dart_options.mixin);
+    if (name.isEmpty) return null; // don't use a mixin (override any default)
+    if (!reservedNamesForMixins.containsKey(name)) {
+      throw("unknown mixin class: ${name}");
+    }
+    return name;
   }
 
   final String classname;
   final String fqname;
-  final bool implementsMap;
+  final String mixin;
 
   final ProtobufContainer _parent;
   final GenerationContext _context;
   final DescriptorProto _descriptor;
   final List<EnumGenerator> _enumGenerators = <EnumGenerator>[];
   final List<ProtobufField> _fieldList = <ProtobufField>[];
   final List<MessageGenerator> _messageGenerators = <MessageGenerator>[];
   final List<ExtensionGenerator> _extensionGenerators = <ExtensionGenerator>[];
   final Set<String> _methodNames = new Set<String>();
 
   MessageGenerator(
       DescriptorProto descriptor, ProtobufContainer parent, this._context,
-      bool implementMapByDefault)
+      String defaultMixin)
       : _descriptor = descriptor,
         _parent = parent,
         classname = (parent.classname == '') ?
             descriptor.name : '${parent.classname}_${descriptor.name}',
         fqname = (parent == null || parent.fqname == null) ? descriptor.name :
             (parent.fqname == '.' ?
                 '.${descriptor.name}' : '${parent.fqname}.${descriptor.name}'),
-        implementsMap = _shouldImplementMap(descriptor, implementMapByDefault) {
+        mixin = _getMixin(descriptor, defaultMixin) {
     _context.register(this);
 
     for (EnumDescriptorProto e in _descriptor.enumType) {
       _enumGenerators.add(new EnumGenerator(e, this, _context));
     }
 
     for (DescriptorProto n in _descriptor.nestedType) {
       _messageGenerators.add(
-          new MessageGenerator(n, this, _context, implementMapByDefault));
+          new MessageGenerator(n, this, _context, defaultMixin));
     }
 
     for (FieldDescriptorProto x in _descriptor.extension) {
       _extensionGenerators.add(new ExtensionGenerator(x, this, _context));
     }
   }
 
   String get package => _parent.package;
 
-  bool get needsMapMixinImport {
-    if (implementsMap) return true;
-
-    for (var m in _messageGenerators) {
-      if (m.implementsMap) return true;
-    }
-
-    return false;
-  }
-
   void initializeFields() {
     _fieldList.clear();
     for (FieldDescriptorProto field in _descriptor.field) {
       _fieldList.add(new ProtobufField(field, this, _context));
     }
     for (MessageGenerator m in _messageGenerators) {
       m.initializeFields();
     }
   }
 
   void generate(IndentingWriter out) {
     _methodNames.clear();
     _methodNames.addAll(reservedWords);
     _methodNames.addAll(reservedNames);
 
-    if (implementsMap) {
-      _methodNames.addAll(reservedNamesForMap);
+    if (mixin != null) {
+      _methodNames.addAll(reservedNamesForMixins[mixin]);
     }
 
     for (EnumGenerator e in _enumGenerators) {
       e.generate(out);
     }
 
     for (MessageGenerator m in _messageGenerators) {
       m.generate(out);
     }
 
-    var implClause = "";
-    if (implementsMap) {
-      implClause = " with MapMixin";
+    var mixinClause = "";
+    if (mixin != null) {
+      mixinClause = " with ${mixin}";

[Søren Gjesse, 2015/06/22 18:29:38]

The new approach currently does not require/support additional imports?

[skybrian, 2015/06/23 02:21:25]

It didn't because the PbMapMixin was in the protobuf package which is already
imported. However, since I moved it, I had to implement import handling again.

     }
 
-    out.addBlock('class ${classname} extends GeneratedMessage${implClause} {',
+    out.addBlock('class ${classname} extends GeneratedMessage${mixinClause} {',
         '}', ()
       {
       out.addBlock(
           'static final BuilderInfo _i = new BuilderInfo(\'${classname}\')',
           ';', () {
         for (ProtobufField field in _fieldList) {
           String type = field.shortTypeName;
           String fieldType = field.baseTypeForPackage(package);
 
           String makeDefault = null;
@@ skipping 69 matching lines @@
           '${SP}new ${classname}()..mergeFromMessage(this);');
 
       out.println('BuilderInfo get info_${SP}=>${SP}_i;');
 
       // Factory functions which can be used as default value closures.
       out.println('static ${classname}${SP}create()${SP}=>'
           '${SP}new ${classname}();');
       out.println('static PbList<${classname}>${SP}createRepeated()${SP}=>'
           '${SP}new PbList<${classname}>();');
 
-
-      if (implementsMap) {
-        // clear() is inherited from GeneratedMessage.
-        // Other map operations are implemented by MapMixin.
-        out.println('''
-@override
-operator [] (key) {
-  if (key is !String) return null;
-  if (!key.contains(".")) {
-    var tag = getTagNumber(key);
-    if (tag == null) return null;
-    return getField(tag);
-  }
-
-  var keys = key.split('.');
-  var item = this;
-  for (var key in keys) {
-    if (item is !GeneratedMessage) return null;
-    var tag = item.getTagNumber(key);
-    if (tag == null) return null;
-    item = item.getField(tag);
-  }
-
-  return item;
-}
-
-@override
-operator []= (String key, val) {
-  if (!key.contains(".")) {
-    var tag = _mustGetTagNumber(this, key);
-    setField(tag, val);
-    return;
-  }
-
-  var keys = key.split('.');
-  var lastKey = keys.removeLast();
-  var item = this;
-  for (var key in keys) {
-    var tag = _mustGetTagNumber(item, key);
-    item = item.getField(tag);
-    if (item is !GeneratedMessage) {
-      throw new ArgumentError(
-          "field '\${key}' in \${info._messageName} isn't a GeneratedMessage:");
-    }
-  }
-  var tag = _mustGetTagNumber(item, lastKey);
-  item.setField(tag, val);
-}
-
-_mustGetTagNumber(GeneratedMessage msg, String key) {
-  var tag = msg.getTagNumber(key);
-  if (tag == null) {
-    throw new ArgumentError(
-        "field '\${key}' not found in \${msg.info_.messageName}");
-  }
-  return tag;
-}
-
-@override
-get keys => info_.byName.keys;
-
-@override
-get length => info_.byName.length;
-
-remove(key) {
-  throw new UnsupportedError("remove() not supported by \${info_.messageName}");
-}
-''');
-      }
-
       generateFieldsAccessorsMutators(out);
     });
     out.println();
   }
 
   // Returns true if the message type has any required fields.  If it doesn't,
   // we can optimize out calls to its isInitialized()/_findInvalidFields()
   // methods.
   //
   // already_seen is used to avoid checking the same type multiple times
@@ skipping 65 matching lines @@
             '(${fieldTypeString} v)${SP}'
             '{${SP}setField(${field.number},${SP}v);${SP}}');
         out.println('bool $hasIdentifier()${SP}=>'
             '${SP}hasField(${field.number});');
         out.println('void $clearIdentifier()${SP}=>'
             '${SP}clearField(${field.number});');
       }
     }
   }
 }