Make summary format stable when adding getters to idl.

pkg/analyzer/tool/summary/generate.dart

 // Copyright (c) 2015, 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.
 
 /**
  * This file contains code to generate serialization/deserialization logic for
  * summaries based on an "IDL" description of the summary format (written in
  * stylized Dart).
  *
  * For each class in the "IDL" input, two corresponding classes are generated:
@@ skipping 64 matching lines @@
    * Semantic model of the "IDL" input file.
    */
   idlModel.Idl _idl;
 
   /**
    * Perform basic sanity checking of the IDL (over and above that done by
    * [extractIdl]).
    */
   void checkIdl() {
     _idl.classes.forEach((String name, idlModel.ClassDeclaration cls) {
+      Map<int, String> idsUsed = <int, String>{};
       for (idlModel.FieldDeclaration field in cls.fields) {
         String fieldName = field.name;
         idlModel.FieldType type = field.type;
         if (type.isList) {
           if (_idl.classes.containsKey(type.typeName)) {
             // List of classes is ok
           } else if (_idl.enums.containsKey(type.typeName)) {
             // List of enums is ok
           } else if (type.typeName == 'int') {
             // List of ints is ok
           } else if (type.typeName == 'double') {
             // List of doubles is ok
           } else if (type.typeName == 'String') {
             // List of strings is ok
           } else {
             throw new Exception(
                 '$name.$fieldName: illegal type (list of ${type.typeName})');
           }
         }
+        if (idsUsed.containsKey(field.id)) {
+          throw new Exception('$name.$fieldName: id ${field.id} already used by'
+              ' ${idsUsed[field.id]}');
+        }
+        idsUsed[field.id] = fieldName;
+      }
+      for (int i = 0; i < idsUsed.length; i++) {
+        if (!idsUsed.containsKey(i)) {
+          throw new Exception('$name: no field uses id $i');
+        }
       }
     });
   }
 
   /**
    * Generate a string representing the Dart type which should be used to
    * represent [type] when deserialized.
    */
   String dartType(idlModel.FieldType type) {
     String baseType = idlPrefix(type.typeName);
@@ skipping 72 matching lines @@
             new idlModel.ClassDeclaration(doc, decl.name.name, isTopLevel);
         _idl.classes[cls.name] = cls;
         String expectedBase = 'base.SummaryClass';
         if (decl.extendsClause == null ||
             decl.extendsClause.superclass.name.name != expectedBase) {
           throw new Exception(
               'Class `${cls.name}` needs to extend `$expectedBase`');
         }
         for (ClassMember classMember in decl.members) {
           if (classMember is MethodDeclaration && classMember.isGetter) {
+            String desc = '${cls.name}.${classMember.name.name}';
             TypeName type = classMember.returnType;
             if (type == null) {
-              throw new Exception('Class member needs a type: $classMember');
+              throw new Exception('Class member needs a type: $desc');
             }
             bool isList = false;
             if (type.name.name == 'List' &&
                 type.typeArguments != null &&
                 type.typeArguments.arguments.length == 1) {
               isList = true;
               type = type.typeArguments.arguments[0];
             }
             if (type.typeArguments != null) {
               throw new Exception('Cannot handle type arguments in `$type`');
             }
+            int id;
+            for (Annotation annotation in classMember.metadata) {
+              if (annotation.name.name == 'Id') {
+                if (id != null) {
+                  throw new Exception(
+                      'Duplicate @id annotation ($classMember)');
+                }
+                if (annotation.arguments.arguments.length != 1) {
+                  throw new Exception(
+                      '@Id must be passed exactly one argument ($desc)');
+                }
+                Expression expression = annotation.arguments.arguments[0];
+                if (expression is IntegerLiteral) {
+                  id = expression.value;
+                } else {
+                  throw new Exception(
+                      '@Id parameter must be an integer literal ($desc)');
+                }
+              }
+            }
+            if (id == null) {
+              throw new Exception('Missing @id annotation ($desc)');
+            }
             String doc = _getNodeDoc(lineInfo, classMember);
             idlModel.FieldType fieldType =
                 new idlModel.FieldType(type.name.name, isList);
             cls.fields.add(new idlModel.FieldDeclaration(
-                doc, classMember.name.name, fieldType));
+                doc, classMember.name.name, fieldType, id));
           } else if (classMember is ConstructorDeclaration &&
               classMember.name.name == 'fromBuffer') {
             // Ignore `fromBuffer` declarations; they simply forward to the
             // read functions generated by [_generateReadFunction].
           } else {
             throw new Exception('Unexpected class member `$classMember`');
           }
         }
       } else if (decl is EnumDeclaration) {
         String doc = _getNodeDoc(lineInfo, decl);
@@ skipping 172 matching lines @@
           out('return fbBuilder.finish(finish(fbBuilder));');
         });
         out('}');
       }
       out();
       out('fb.Offset finish(fb.Builder fbBuilder) {');
       indent(() {
         out('assert(!_finished);');
         out('_finished = true;');
         // Write objects and remember Offset(s).
-        cls.fields.asMap().forEach((index, idlModel.FieldDeclaration field) {
+        for (idlModel.FieldDeclaration field in cls.fields) {
           idlModel.FieldType fieldType = field.type;
           String offsetName = 'offset_' + field.name;
           if (fieldType.isList ||
               fieldType.typeName == 'String' ||
               _idl.classes.containsKey(fieldType.typeName)) {
             out('fb.Offset $offsetName;');
           }
-        });
-        cls.fields.asMap().forEach((index, idlModel.FieldDeclaration field) {
+        }
+        for (idlModel.FieldDeclaration field in cls.fields) {
           idlModel.FieldType fieldType = field.type;
           String valueName = '_' + field.name;
           String offsetName = 'offset_' + field.name;
           String condition;
           String writeCode;
           if (fieldType.isList) {
             condition = ' || $valueName.isEmpty';
             if (_idl.classes.containsKey(fieldType.typeName)) {
               String itemCode = 'b.finish(fbBuilder)';
               String listCode = '$valueName.map((b) => $itemCode).toList()';
@@ skipping 23 matching lines @@
             if (condition == null) {
               out('if ($valueName != null) {');
             } else {
               out('if (!($valueName == null$condition)) {');
             }
             indent(() {
               out(writeCode);
             });
             out('}');
           }
-        });
+        }
         // Write the table.
         out('fbBuilder.startTable();');
-        cls.fields.asMap().forEach((index, idlModel.FieldDeclaration field) {
+        for (idlModel.FieldDeclaration field in cls.fields) {
+          int index = field.id;
           idlModel.FieldType fieldType = field.type;
           String valueName = '_' + field.name;
           String condition = '$valueName != null';
           String writeCode;
           if (fieldType.isList ||
               fieldType.typeName == 'String' ||
               _idl.classes.containsKey(fieldType.typeName)) {
             String offsetName = 'offset_' + field.name;
             condition = '$offsetName != null';
             writeCode = 'fbBuilder.addOffset($index, $offsetName);';
           } else if (fieldType.typeName == 'bool') {
             condition = '$valueName == true';
             writeCode = 'fbBuilder.addBool($index, true);';
           } else if (fieldType.typeName == 'int') {
             condition += ' && $valueName != ${defaultValue(fieldType, true)}';
             writeCode = 'fbBuilder.addUint32($index, $valueName);';
           } else if (_idl.enums.containsKey(fieldType.typeName)) {
             condition += ' && $valueName != ${defaultValue(fieldType, true)}';
             writeCode = 'fbBuilder.addUint32($index, $valueName.index);';
           }
           if (writeCode == null) {
             throw new UnimplementedError('Writing type ${fieldType.typeName}');
           }
           out('if ($condition) {');
           indent(() {
             out(writeCode);
           });
           out('}');
-        });
+        }
         out('return fbBuilder.endTable();');
       });
       out('}');
     });
     out('}');
   }
 
   void _generateEnumReader(idlModel.EnumDeclaration enm) {
     String name = enm.name;
     String readerName = '_${name}Reader';
@@ skipping 26 matching lines @@
       out();
       out('$implName(this._bp);');
       out();
       // Write cache fields.
       for (idlModel.FieldDeclaration field in cls.fields) {
         String returnType = dartType(field.type);
         String fieldName = field.name;
         out('$returnType _$fieldName;');
       }
       // Write getters.
-      cls.fields.asMap().forEach((index, field) {
+      for (idlModel.FieldDeclaration field in cls.fields) {
+        int index = field.id;
         String fieldName = field.name;
         idlModel.FieldType type = field.type;
         String typeName = type.typeName;
         // Prepare "readCode" + "def"
         String readCode;
         String def = defaultValue(type, false);
         if (type.isList) {
           if (typeName == 'int') {
             String itemCode = 'const fb.Uint32Reader()';
             readCode = 'const fb.ListReader<int>($itemCode)';
@@ skipping 26 matching lines @@
         out();
         out('@override');
         String returnType = dartType(type);
         out('$returnType get $fieldName {');
         indent(() {
           String readExpr = '$readCode.vTableGet(_bp, $index, $def)';
           out('_$fieldName ??= $readExpr;');
           out('return _$fieldName;');
         });
         out('}');
-      });
+      }
     });
     out('}');
   }
 
   void _generateMixin(idlModel.ClassDeclaration cls) {
     String name = cls.name;
     String mixinName = '_${name}Mixin';
     out('abstract class $mixinName implements ${idlPrefix(name)} {');
     indent(() {
       // Write toMap().
@@ skipping 50 matching lines @@
       return token.lexeme.split('\n').map((String line) {
         if (line.startsWith(indent)) {
           line = line.substring(indent.length);
         }
         return line;
       }).join('\n');
     }
     return null;
   }
 }