changes for 0.3.9

lib/file_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;
 
 class FileGenerator extends ProtobufContainer {
-  // This should match the extension in dart_options.proto.
-  static const int implementMapByDefaultOption = 95333044;
 
-  // Returns true if option implement_map_by_default is on for this file.
-  static bool _shouldImplementMapByDefault(FileDescriptorProto desc) {
-    if (!desc.hasOptions()) return false;
-
-    var val = desc.options.unknownFields.getField(implementMapByDefaultOption);
-    if (val == null || val.length != 1) return false;
-
-    return val.values[0] == 1;
+  /// Returns the the mixin to use by default in this file,
+  /// or null for no mixin by default.
+  static PbMixin _getDefaultMixin(FileDescriptorProto desc) {
+    if (!desc.hasOptions()) return null;
+    if (!desc.options.hasExtension(Dart_options.defaultMixin)) {
+      return null;
+    }
+    var name = desc.options.getExtension(Dart_options.defaultMixin);
+    PbMixin mixin = findMixin(name);
+    if (mixin == null) {
+      throw("unknown mixin class: ${name}");
+    }
+    return mixin;
   }
 
   final FileDescriptorProto _fileDescriptor;
   final ProtobufContainer _parent;
   final GenerationContext _context;
 
   final List<EnumGenerator> enumGenerators = <EnumGenerator>[];
   final List<MessageGenerator> messageGenerators = <MessageGenerator>[];
   final List<ExtensionGenerator> extensionGenerators = <ExtensionGenerator>[];
 
   FileGenerator(this._fileDescriptor, this._parent, this._context) {
     _context.register(this);
 
-    bool implementMap = _shouldImplementMapByDefault(_fileDescriptor);
+    var defaultMixin = _getDefaultMixin(_fileDescriptor);
 
     // Load and register all enum and message types.
     for (EnumDescriptorProto enumType in _fileDescriptor.enumType) {
       enumGenerators.add(new EnumGenerator(enumType, this, _context));
     }
     for (DescriptorProto messageType in _fileDescriptor.messageType) {
       messageGenerators.add(
-          new MessageGenerator(messageType, this, _context, implementMap));
+          new MessageGenerator(messageType, this, _context, defaultMixin));
     }
     for (FieldDescriptorProto extension in _fileDescriptor.extension) {
       extensionGenerators.add(
           new ExtensionGenerator(extension, this, _context));
     }
   }
 
   String get package => _fileDescriptor.package;
   String get classname => '';
   String get fqname => '.${_fileDescriptor.package}';
@@ skipping 39 matching lines @@
     out.println(
       '///\n'
       '//  Generated code. Do not modify.\n'
       '///\n'
       'library $libraryName;\n'
       '\n'
       "import 'package:fixnum/fixnum.dart';\n"
       "import 'package:protobuf/protobuf.dart';"
     );
 
-    if (needsMapMixinImport) {
-      out.println("import 'dart:collection' show MapMixin;");
+    var mixinImports = findMixinsToImport();
+    var importNames = mixinImports.keys.toList();
+    importNames.sort();
+    for (var imp in importNames) {
+      var symbols = mixinImports[imp];
+      out.println("import '${imp}' show ${symbols.join(', ')};");

[Søren Gjesse, 2015/06/23 06:43:33]

This import could cause name-clashes. Should these imports always be generated
using a unique 'as' name?

[skybrian, 2015/06/23 17:32:42]

It's a good point but I'm going to defer this, since we don't allow arbitrary
mixins to be used yet.

Name conflicts should be very rare because the name of a mixin class usually
ends with "Mixin" and proto messages are unlikely to have names ending with
"Mixin". (I did a code search and found one example.)

[Søren Gjesse, 2015/06/24 07:11:27]

Please file an issue on this.

     }
 
     for (String import in _fileDescriptor.dependency) {
       Uri importPath = new Uri.file(import);
       if (importPath.isAbsolute) {
         // protoc should never generate an import with an absolute path.
         throw("FAILURE: Import with absolute path is not supported");
       }
       // Create a path from the current file to the imported proto.
       Uri resolvedImport = _context.outputConfiguration.resolveImport(
@@ skipping 34 matching lines @@
         out.println('static void registerAllExtensions(ExtensionRegistry '
             'registry) {');
         for (ExtensionGenerator x in extensionGenerators) {
           out.println('  registry.add(${x.name});');
         }
         out.println('}');
       });
     }
   }
 
-  bool get needsMapMixinImport {
-    for (var m in messageGenerators) {
-      if (m.needsMapMixinImport) {
-        return true;
-      }
+  /// Returns a map from import names to the Dart symbols to be imported.
+  Map<String, List<String>> findMixinsToImport() {
+    var mixins = new Set<PbMixin>();
+    for (MessageGenerator m in messageGenerators) {
+      m.addMixinsTo(mixins);
     }
-    return false;
+
+    var imports = {};
+    for (var m in mixins) {
+        var imp = m.importFrom;
+        List<String> symbols = imports[imp];
+        if (symbols == null) {
+          symbols = [];
+          imports[imp] = symbols;
+        }
+        symbols.add(m.name);
+    }
+
+    for (var imp in imports.keys) {
+      imports[imp].sort();
+    }
+
+    return imports;
   }
 }
 
 class GenerationContext {
   final GenerationOptions options;
   final OutputConfiguration outputConfiguration;
   final Map<String, ProtobufContainer> _registry =
       <String, ProtobufContainer>{};
   final Map<String, FileGenerator> _files =
       <String, FileGenerator>{};
 
   GenerationContext(this.options, this.outputConfiguration);
 
   void register(ProtobufContainer container) {
     _registry[container.fqname] = container;
     if (container is FileGenerator) {
       _files[container._fileDescriptor.name] = container;
     }
   }
 
   ProtobufContainer operator [](String fqname) => _registry[fqname];
 
   FileGenerator lookupFile(String name) => _files[name];
 }