Use package names as import prefixes when generating code

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 implements ProtobufContainer {
   // List of names which cannot be used in a subclass of GeneratedMessage.
   static final List<String> reservedNames =
     ['hashCode', 'noSuchMethod','runtimeType', 'toString',
      'fromBuffer', 'fromJson', 'hasRequiredFields', 'isInitialized',
      'clear', 'getTagNumber', 'check',
      'writeToBuffer', 'writeToCodedBufferWriter',
      'mergeFromCodedBufferReader', 'mergeFromBuffer',
      'writeToJson', 'mergeFromJson',
      'addExtension', 'getExtension', 'setExtension',
      'hasExtension', 'clearExtension',
      'getField', 'setField', 'hasField', 'clearField',
      'extensionsAreInitialized', 'mergeFromMessage', 'mergeUnknownFields',
      '==', 'info_', 'GeneratedMessage', 'Object'];
 
   final String classname;
   final String fqname;
+  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)
+  MessageGenerator(
+      DescriptorProto descriptor, ProtobufContainer parent, this._context)
       : _descriptor = descriptor,
-        classname = (parent == null || parent.classname == '') ?
+        _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}') {
     _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));
     }
 
     for (FieldDescriptorProto x in _descriptor.extension) {
       _extensionGenerators.add(new ExtensionGenerator(x, this, _context));
     }
   }
 
+  String get package => _parent.package;
+
   void initializeFields() {
     _fieldList.clear();
     for (FieldDescriptorProto field in _descriptor.field) {
       _fieldList.add(new ProtobufField(field, this, _context));
     }
     for (MessageGenerator m in _messageGenerators) {
       m.initializeFields();
     }
   }
 
@@ skipping 10 matching lines @@
     }
 
     out.addBlock('class ${classname} extends GeneratedMessage${SP}{',
         '}', ()
       {
       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;
           if (field.hasInitialization) {
-            makeDefault = '${field.initialization}';
+            makeDefault = field.initializationForPackage(package);
           }
           String subBuilder = null;
           if (field.message || field.group) {
-            subBuilder = '()${SP}=>${SP}new ${field.baseType}()';
+            subBuilder = '()${SP}=>${SP}new ${fieldType}()';
           }
           String valueOf = null;
           if (field.enm) {
-            valueOf = '(var v)${SP}=>${SP}${field.baseType}.valueOf(v)';
+            valueOf = '(var v)${SP}=>${SP}${fieldType}.valueOf(v)';
           }
           if ('PM' == type) {
             // Repeated message: default is an empty list
             out.println('..m(${field.number},${SP}'
                 '\'${field.externalFieldName}\',${SP}$subBuilder,'
-                '${SP}()${SP}=>${SP}new PbList<${field.baseType}>())');
+                '${SP}()${SP}=>${SP}new PbList<${fieldType}>())');
           } else if (type[0] == 'P' && type != 'PG' && type != 'PE') {
             // Repeated, not a message or enum: default is an empty list,
             // subBuilder is null, valueOf is null.
             out.println('..p(${field.number},${SP}'
                 '\'${field.externalFieldName}\',${SP}GeneratedMessage.$type)');
           } else if (type == 'OE' || type == 'QE') {
             out.println('..e(${field.number},${SP}'
                 '\'${field.externalFieldName}\',${SP}GeneratedMessage.$type,'
                 '${SP}$makeDefault,${SP}$valueOf)');
           } else {
@@ skipping 105 matching lines @@
         }
         _methodNames.add(identifier);
         _methodNames.add(hasIdentifier);
         _methodNames.add(clearIdentifier);
       } else {
         while (_methodNames.contains(identifier)) {
           identifier += '_' + field.number.toString();
         }
         _methodNames.add(identifier);
       }
-      out.println('${field.typeString} get ${identifier}'
+      var fieldTypeString = field.typeStringForPackage(package);
+      out.println('${fieldTypeString} get ${identifier}'
           '${SP}=>${SP}getField(${field.number});');
       if (field.single) {
         out.println('void set ${identifier}'
-            '(${field.typeString} v)${SP}'
+            '(${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});');
       }
     }
   }
 }