Protobuf changes for smaller dart2js code, Int64 fixes

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]+$');
@@ skipping 121 matching lines @@
     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}';
+            initialization = '${field.defaultValue}';
           }
         }
         break;
       case FieldDescriptorProto_Type.TYPE_FLOAT:
       case FieldDescriptorProto_Type.TYPE_DOUBLE:
         baseType = 'double';
         typeString = write('double');
         packable = true;
         codedStreamType =
             (field.type == FieldDescriptorProto_Type.TYPE_FLOAT) ?
                 'Float' : 'Double';
         if (!repeats) {
           if (field.hasDefaultValue() &&
               ('0.0' != field.defaultValue || '0' != field.defaultValue)) {
             if (field.defaultValue == 'inf') {
-              initialization = '()${SP}=>${SP}double.INFINITY';
+              initialization = 'double.INFINITY';
             } else if (field.defaultValue == '-inf') {
-              initialization = '()${SP}=>${SP}double.NEGATIVE_INFINITY';
+              initialization = 'double.NEGATIVE_INFINITY';
             } else if (field.defaultValue == 'nan') {
-              initialization = '()${SP}=>${SP}double.NAN';
+              initialization = 'double.NAN';
             } else if (HEX_LITERAL_REGEX.hasMatch(field.defaultValue)) {
-              initialization = '()${SP}=>${SP}(${field.defaultValue})'
-                  '.toDouble()';
+              initialization = '(${field.defaultValue}).toDouble()';
             } else if (INTEGER_LITERAL_REGEX.hasMatch(field.defaultValue)) {
-              initialization = '()${SP}=>${SP}${field.defaultValue}.0';
+              initialization = '${field.defaultValue}.0';
             } else if (DECIMAL_LITERAL_REGEX_A.hasMatch(field.defaultValue)
                       || DECIMAL_LITERAL_REGEX_B.hasMatch(field.defaultValue)) {
-              initialization = '()${SP}=>${SP}${field.defaultValue}';
+              initialization = '${field.defaultValue}';
             } else {
               throw new InvalidDefaultValue.double(
                   field.name, field.defaultValue);
             }
           }
         }
         break;
       case FieldDescriptorProto_Type.TYPE_INT32:
       case FieldDescriptorProto_Type.TYPE_UINT32:
       case FieldDescriptorProto_Type.TYPE_SINT32:
@@ skipping 14 matching lines @@
             break;
           case FieldDescriptorProto_Type.TYPE_FIXED32:
             codedStreamType = 'Fixed32';
             break;
           case FieldDescriptorProto_Type.TYPE_SFIXED32:
             codedStreamType = 'Sfixed32';
             break;
         }
         if (!repeats) {
           if (field.hasDefaultValue() && '0' != field.defaultValue) {
-            initialization = '()${SP}=>${SP}${field.defaultValue}';
+            initialization = '${field.defaultValue}';
           }
         }
         break;
       case FieldDescriptorProto_Type.TYPE_INT64:
       case FieldDescriptorProto_Type.TYPE_UINT64:
       case FieldDescriptorProto_Type.TYPE_SINT64:
       case FieldDescriptorProto_Type.TYPE_FIXED64:
       case FieldDescriptorProto_Type.TYPE_SFIXED64:
         baseType = 'Int64';
         typeString = write('Int64');
@@ skipping 11 matching lines @@
           case FieldDescriptorProto_Type.TYPE_FIXED64:
             codedStreamType = 'Fixed64';
             break;
           case FieldDescriptorProto_Type.TYPE_SFIXED64:
             codedStreamType = 'Sfixed64';
             break;
         }
         if (!repeats) {
           final defaultValue = field.hasDefaultValue() ?
               field.defaultValue : '0';
-          initialization = '()${SP}=>${SP}makeLongInt($defaultValue)';
+          if (defaultValue == '0') {
+            initialization = 'Int64.ZERO';
+          } else {
+            initialization = "parseLongInt('$defaultValue')";
+          }
         }
         break;
       case FieldDescriptorProto_Type.TYPE_STRING:
         baseType = 'String';
         typeString = write('String');
         codedStreamType = 'String';
         if (!repeats) {
           if (field.hasDefaultValue() && !field.defaultValue.isEmpty) {
             String defaultValue = field.defaultValue.replaceAll(r'$', r'\$');
-            initialization = '()${SP}=>${SP}\'$defaultValue\'';
+            initialization = '\'$defaultValue\'';
           }
         }
         break;
       case FieldDescriptorProto_Type.TYPE_BYTES:
         baseType = 'List<int>';
         typeString = write('List<int>');
         codedStreamType = 'Bytes';
         if (!repeats) {
           if (field.hasDefaultValue() && !field.defaultValue.isEmpty) {
             String byteList = field.defaultValue.codeUnits
@@ skipping 12 matching lines @@
           if (groupType.packageImportPrefix.isNotEmpty) {
            prefixedBaseType = groupType.packageImportPrefix + '.' + baseType;
           } else {
            prefixedBaseType = baseType;
           }
           prefixedTypeString = write(prefixedBaseType);
           codedStreamType = 'Group';
         } else {
           throw 'FAILURE: Unknown group type reference ${field.typeName}';
         }
         initialization = '()${SP}=>${SP}new ${baseType}()';

[Siggi Cherem (dart-lang), 2014/12/19 21:53:14]

and probably change here too

[sra1, 2014/12/19 23:11:02]

Done.

         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(baseType);
           if (messageType.packageImportPrefix.isNotEmpty) {
             prefixedBaseType = messageType.packageImportPrefix + '.' + baseType;
           } else {
             prefixedBaseType = 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}()';
+        initialization = '${baseType}.create';
+        prefixedInitialization = '${prefixedBaseType}.create';
         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';
           if (enumType.packageImportPrefix.isNotEmpty) {
             prefixedBaseType = enumType.packageImportPrefix + '.' + baseType;
           } else {
             prefixedBaseType = baseType;
           }
           prefixedTypeString = write(prefixedBaseType);
           packable = true;
           if (!repeats) {
             if (field.hasDefaultValue() && !field.defaultValue.isEmpty) {
               initialization =
-                  '()${SP}=>${SP}${baseType}.${field.defaultValue}';
+                  '${baseType}.${field.defaultValue}';
               prefixedInitialization =
-                  '()${SP}=>${SP}${prefixedBaseType}.${field.defaultValue}';
+                  '${prefixedBaseType}.${field.defaultValue}';
             } else if (!enumType._canonicalValues.isEmpty) {
               initialization =
-                  '()${SP}=>${SP}${baseType}.'
-                  '${enumType._canonicalValues[0].name}';
+                  '${baseType}.${enumType._canonicalValues[0].name}';
               prefixedInitialization =
-                  '()${SP}=>${SP}${prefixedBaseType}.'
-                  '${enumType._canonicalValues[0].name}';
+                  '${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.
     }
@@ skipping 58 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
     }
   }
 }