Add file identifiers to summaries.

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 68 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) {
+      if (cls.fileIdentifier != null) {
+        if (cls.fileIdentifier.length != 4) {
+          throw new Exception('$name: file identifier must be 4 characters');
+        }
+        for (int i = 0; i < cls.fileIdentifier.length; i++) {
+          if (cls.fileIdentifier.codeUnitAt(i) >= 256) {
+            throw new Exception(
+                '$name: file identifier must be encodable as Latin-1');
+          }
+        }
+      }
       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') {
@@ skipping 84 matching lines @@
 
   /**
    * Process the AST in [idlParsed] and store the resulting semantic model in
    * [_idl].  Also perform some error checking.
    */
   void extractIdl(LineInfo lineInfo, CompilationUnit idlParsed) {
     _idl = new idlModel.Idl();
     for (CompilationUnitMember decl in idlParsed.declarations) {
       if (decl is ClassDeclaration) {
         bool isTopLevel = false;
+        String fileIdentifier;
+        String clsName = decl.name.name;
         for (Annotation annotation in decl.metadata) {
-          if (annotation.arguments == null &&
-              annotation.name.name == 'topLevel') {
+          if (annotation.arguments != null &&
+              annotation.name.name == 'TopLevel' &&
+              annotation.constructorName == null) {
             isTopLevel = true;
+            if (annotation.arguments == null) {
+              throw new Exception(
+                  'Class `$clsName`: TopLevel requires parenthesis');
+            }
+            if (annotation.constructorName != null) {
+              throw new Exception(
+                  "Class `$clsName`: TopLevel doesn't have named constructors");
+            }
+            if (annotation.arguments.arguments.length == 1) {
+              Expression arg = annotation.arguments.arguments[0];
+              if (arg is StringLiteral) {
+                fileIdentifier = arg.stringValue;
+              } else {
+                throw new Exception(
+                    'Class `$clsName`: TopLevel argument must be a string'
+                    ' literal');
+              }
+            } else if (annotation.arguments.arguments.length != 0) {
+              throw new Exception(
+                  'Class `$clsName`: TopLevel requires 0 or 1 arguments');
+            }
           }
         }
         String doc = _getNodeDoc(lineInfo, decl);
-        idlModel.ClassDeclaration cls =
-            new idlModel.ClassDeclaration(doc, decl.name.name, isTopLevel);
-        _idl.classes[cls.name] = cls;
+        idlModel.ClassDeclaration cls = new idlModel.ClassDeclaration(
+            doc, clsName, isTopLevel, fileIdentifier);
+        _idl.classes[clsName] = 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`');
+              'Class `$clsName` needs to extend `$expectedBase`');
         }
         for (ClassMember classMember in decl.members) {
           if (classMember is MethodDeclaration && classMember.isGetter) {
-            String desc = '${cls.name}.${classMember.name.name}';
+            String desc = '$clsName.${classMember.name.name}';
             TypeName type = classMember.returnType;
             if (type == null) {
               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];
@@ skipping 205 matching lines @@
         String prefix = i == 0 ? '  : ' : '    ';
         String suffix = i == cls.fields.length - 1 ? ';' : ',';
         out('${prefix}_${field.name} = ${field.name}$suffix');
       }
       // Generate finish.
       if (cls.isTopLevel) {
         out();
         out('List<int> toBuffer() {');
         indent(() {
           out('fb.Builder fbBuilder = new fb.Builder();');
-          out('return fbBuilder.finish(finish(fbBuilder));');
+          String fileId = cls.fileIdentifier == null
+              ? ''
+              : ', ${quoted(cls.fileIdentifier)}';
+          out('return fbBuilder.finish(finish(fbBuilder)$fileId);');
         });
         out('}');
       }
       out();
       out('fb.Offset finish(fb.Builder fbBuilder) {');
       indent(() {
         out('assert(!_finished);');
         out('_finished = true;');
         // Write objects and remember Offset(s).
         for (idlModel.FieldDeclaration field in cls.fields) {
@@ skipping 283 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;
   }
 }