Use package names as import prefixes when generating code

lib/protobuf_field.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 ProtobufField {
   static final RegExp HEX_LITERAL_REGEX =
       new RegExp(r'^0x[0-9a-f]+$', multiLine: false, caseSensitive: false);
   static final RegExp INTEGER_LITERAL_REGEX = new RegExp(r'^[+-]?[0-9]+$');
   static final RegExp DECIMAL_LITERAL_REGEX_A =
       new RegExp(r'^[+-]?([0-9]*)\.[0-9]+(e[+-]?[0-9]+)?$',
                  multiLine: false, caseSensitive: false);
   static final RegExp DECIMAL_LITERAL_REGEX_B =
       new RegExp(r'^[+-]?[0-9]+e[+-]?[0-9]+$', multiLine: false,
                  caseSensitive: false);
 
   final FieldDescriptorProto _field;
   final ProtobufContainer parent;
   final GenerationContext context;
   final String fqname;

[Siggi Cherem (dart-lang), 2013/12/20 18:27:36]

I know this is unrelated, but what does 'fqname' stand for?

[Søren Gjesse, 2014/01/02 08:52:33]

fqname is the "fully qualified name", that is the field name prefixed by the
fqname of the class. The fqname of the class is the class name prefoxed by a .
and the package name (if any).

[Siggi Cherem (dart-lang), 2014/01/02 18:29:46]

I see, thanks for the clarification!

I think renaming this to qualifiedName or something similar would totally be
worth it in the future.

+  final String typePackage;
   final String baseType;
   final String typeString;
+  final String prefixedBaseType;

[Siggi Cherem (dart-lang), 2013/12/20 18:27:36]

should we make these getters instead?

[Søren Gjesse, 2014/01/02 08:52:33]

I decided to keep the current structure of final fields for this change. We
should consider changing most of these finals to getters.

+  final String prefixedTypeString;
   final String codedStreamType;
   final bool repeats;
   final String initialization;
+  final String prefixedInitialization;
   final bool required;
   // True if the field is to be encoded with [packed=true] encoding.
   final bool packed;
   // True if the fields's type can handle [packed=true] encoding.
   final bool packable;
 
   bool get single => !repeats;
 
   bool get group => type == FieldDescriptorProto_Type.TYPE_GROUP;
   bool get message => type == FieldDescriptorProto_Type.TYPE_MESSAGE;
   bool get enm => type == FieldDescriptorProto_Type.TYPE_ENUM;
   bool get primitive => !group && !message;
 
   bool get hasInitialization => initialization != null;
 
   bool get optional => !required; // includes repeated
 
   // Delegate methods.
   String get name => _field.name;
   int get number => _field.number;
   FieldDescriptorProto_Label get label => _field.label;
   FieldDescriptorProto_Type get type => _field.type;
   FieldOptions get options => _field.options;
   String get typeName => _field.typeName;
 
+  String baseTypeForPackage(String package) =>
+      package == typePackage ? baseType : prefixedBaseType;
+  String typeStringForPackage(String package) =>
+      package == typePackage ? typeString : prefixedTypeString;
+  String initializationForPackage(String package) =>
+      package == typePackage ? initialization : prefixedInitialization;
+
   String get shortTypeName {
     String prefix;
     if (required) {
       prefix = 'Q';
     } else if (packed) {
       prefix = 'K';
     } else if (repeats) {
       prefix = 'P';
     } else if (optional) {
       prefix = 'O';
@@ skipping 17 matching lines @@
       case 'FIXED32': return '${prefix}F3';
       case 'FIXED64': return '${prefix}F6';
       case 'SFIXED32': return '${prefix}SF3';
       case 'SFIXED64': return '${prefix}SF6';
       case 'MESSAGE': return '${prefix}M';
     }
     throw 'Unknown type';
   }
 
   ProtobufField._(
-      field, parent, this.context, this.baseType, this.typeString,
-      this.codedStreamType, this.repeats, this.initialization, this.required,
+      field, parent, this.context, this.typePackage, this.baseType,
+      this.typeString, this.prefixedBaseType, this.prefixedTypeString,
+      this.codedStreamType, this.repeats,
+      this.initialization, this.prefixedInitialization, this.required,
       this.packed, this.packable) :
           this._field = field,
           this.parent = parent,
           fqname = '${parent.fqname}.${field.name}';
 
 
   factory ProtobufField(FieldDescriptorProto field,
                         MessageGenerator parent,
                         GenerationContext context) {
     bool required = field.label == FieldDescriptorProto_Label.LABEL_REQUIRED;
     bool repeats = field.label == FieldDescriptorProto_Label.LABEL_REPEATED;
     bool packed = false;
 
     var write;
     if (repeats) {
       packed = field.options == null ? false : field.options.packed;
       write = (String typeString) => 'List<$typeString>';
     } else {
       write = (String typeString) => typeString;
     }
 
+    String typePackage = '';
     String baseType;
     String typeString;
+    String prefixedBaseType;
+    String prefixedTypeString;
     bool packable = false;
     String codedStreamType;
     String initialization;
+    String prefixedInitialization;
     switch (field.type) {
       case FieldDescriptorProto_Type.TYPE_BOOL:
         baseType = 'bool';
         typeString = write('bool');
         packable = true;
         codedStreamType = 'Bool';
         if (!repeats) {
           if (field.hasDefaultValue() && 'false' != field.defaultValue) {
             initialization = '()${SP}=>${SP}${field.defaultValue}';
           }
@@ skipping 113 matching lines @@
             String byteList = field.defaultValue.codeUnits
                 .map((b) => '0x${b.toRadixString(16)}')
                 .join(',');
             initialization = '()${SP}=>${SP}<int>[$byteList]';
           }
         }
         break;
       case FieldDescriptorProto_Type.TYPE_GROUP:
         ProtobufContainer groupType = context[field.typeName];
         if (groupType != null) {
+          typePackage = groupType.package;
           baseType = groupType.classname;
           typeString = write(groupType.classname);
+          prefixedBaseType = groupType.package + '.' + baseType;
+          prefixedTypeString = write(prefixedBaseType);
           codedStreamType = 'Group';
         } else {
           throw 'FAILURE: Unknown group type reference ${field.typeName}';
         }
         initialization = '()${SP}=>${SP}new ${baseType}()';
+        prefixedInitialization = '()${SP}=>${SP}new ${prefixedBaseType}()';
         break;
       case FieldDescriptorProto_Type.TYPE_MESSAGE:
         ProtobufContainer messageType = context[field.typeName];
         if (messageType != null) {
+          typePackage = messageType.package;
           baseType = messageType.classname;
-          typeString = write(messageType.classname);
+          typeString = write(baseType);
+          prefixedBaseType = messageType.package + '.' + baseType;
+          prefixedTypeString = write(prefixedBaseType);
           codedStreamType = 'Message';
         } else {
           throw 'FAILURE: Unknown message type reference ${field.typeName}';
         }
         initialization = '()${SP}=>${SP}new ${baseType}()';
+        prefixedInitialization = '()${SP}=>${SP}new ${prefixedBaseType}()';
         break;
       case FieldDescriptorProto_Type.TYPE_ENUM:
         EnumGenerator enumType = context[field.typeName];
         if (enumType != null) {
+          typePackage = enumType.package;
           baseType = enumType.classname;
           typeString = write(enumType.classname);
           codedStreamType = 'Enum';
+          prefixedBaseType = enumType.package + '.' + baseType;
+          prefixedTypeString = write(prefixedBaseType);
           packable = true;
           if (!repeats) {
             if (field.hasDefaultValue() && !field.defaultValue.isEmpty) {
               initialization =
-                  '()${SP}=>${SP}${enumType.classname}.${field.defaultValue}';
+                  '()${SP}=>${SP}${baseType}.${field.defaultValue}';
+              prefixedInitialization =
+                  '()${SP}=>${SP}${prefixedBaseType}.${field.defaultValue}';
             } else if (!enumType._canonicalValues.isEmpty) {
               initialization =
-                  '()${SP}=>${SP}${enumType.classname}.'
+                  '()${SP}=>${SP}${baseType}.'
+                  '${enumType._canonicalValues[0].name}';
+              prefixedInitialization =
+                  '()${SP}=>${SP}${prefixedBaseType}.'
                   '${enumType._canonicalValues[0].name}';
             }
           }
         } else {
           throw 'FAILURE: Unknown enum type reference ${field.typeName}';
         }
         break;
       default:
         throw 'Unknown type ${field.type.name}';
       // No default -- should be an error.
     }
 
     if (repeats) {
       initialization = '()${SP}=>${SP}new PbList()';
     }
 
+    if (prefixedBaseType == null) prefixedBaseType = baseType;
+    if (prefixedTypeString == null) prefixedTypeString = typeString;
+    if (prefixedInitialization == null) prefixedInitialization = initialization;
     return new ProtobufField._(
-        field, parent, context, baseType, typeString, codedStreamType, repeats,
-        initialization, required, packed, packable);
+        field, parent, context, typePackage, baseType, typeString,
+        prefixedBaseType, prefixedTypeString, codedStreamType, repeats,
+        initialization, prefixedInitialization, required, packed, packable);
   }
 
   // camelCase field name.
   String get externalFieldName {
     String name = titlecaseFieldName;
     return '${name[0].toLowerCase()}${name.substring(1)}';
   }
 
   // TitleCase field name.
   String get titlecaseFieldName {
@@ skipping 36 matching lines @@
         return 2; // Length-delimited
       case FieldDescriptorProto_Type.TYPE_GROUP:
         return 3; // Start group
       case FieldDescriptorProto_Type.TYPE_FLOAT:
       case FieldDescriptorProto_Type.TYPE_FIXED32:
       case FieldDescriptorProto_Type.TYPE_SFIXED32:
         return 5; // 32-bit
     }
   }
 }