Use summary IDL file for interface classes.

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 26 matching lines @@
   String script = Platform.script.toFilePath(windows: Platform.isWindows);
   String pkgPath = normalize(join(dirname(script), '..', '..'));
   GeneratedContent.generateAll(pkgPath, <GeneratedContent>[target]);
 }
 
 final GeneratedFile target =
     new GeneratedFile('lib/src/summary/format.dart', (String pkgPath) {
   // Parse the input "IDL" file and pass it to the [_CodeGenerator].
   PhysicalResourceProvider provider = new PhysicalResourceProvider(
       PhysicalResourceProvider.NORMALIZE_EOL_ALWAYS);
-  String idlPath = join(pkgPath, 'tool', 'summary', 'idl.dart');
+  String idlPath = join(pkgPath, 'lib', 'src', 'summary', 'idl.dart');
   File idlFile = provider.getFile(idlPath);
   Source idlSource = provider.getFile(idlPath).createSource();
   String idlText = idlFile.readAsStringSync();
   BooleanErrorListener errorListener = new BooleanErrorListener();
   CharacterReader idlReader = new CharSequenceReader(idlText);
   Scanner scanner = new Scanner(idlSource, idlReader, errorListener);
   Token tokenStream = scanner.tokenize();
   LineInfo lineInfo = new LineInfo(scanner.lineStarts);
   Parser parser = new Parser(idlSource, new BooleanErrorListener());
   CompilationUnit idlParsed = parser.parseCompilationUnit(tokenStream);
@@ skipping 45 matching lines @@
         }
       }
     });
   }
 
   /**
    * 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);
     if (type.isList) {
-      return 'List<${type.typeName}>';
+      return 'List<$baseType>';
     } else {
-      return type.typeName;
+      return baseType;
     }
   }
 
   /**
    * Generate a Dart expression representing the default value for a field
    * having the given [type], or `null` if there is no default value.
    *
    * If [builder] is `true`, the returned type should be appropriate for use in
    * a builder class.
    */
   String defaultValue(idlModel.FieldType type, bool builder) {
     if (type.isList) {
       if (builder) {
         idlModel.FieldType elementType =
             new idlModel.FieldType(type.typeName, false);
         return '<${encodedType(elementType)}>[]';
       } else {
-        return 'const <${type.typeName}>[]';
+        return 'const <${idlPrefix(type.typeName)}>[]';
       }
     } else if (_idl.enums.containsKey(type.typeName)) {
-      return '${type.typeName}.${_idl.enums[type.typeName].values[0].name}';
+      return '${idlPrefix(type.typeName)}.'
+          '${_idl.enums[type.typeName].values[0].name}';
     } else if (type.typeName == 'int') {
       return '0';
     } else if (type.typeName == 'String') {
       return "''";
     } else if (type.typeName == 'bool') {
       return 'false';
     } else {
       return null;
     }
   }
 
   /**
    * Generate a string representing the Dart type which should be used to
    * represent [type] while building a serialized data structure.
    */
   String encodedType(idlModel.FieldType type) {
     String typeStr;
     if (_idl.classes.containsKey(type.typeName)) {
       typeStr = '${type.typeName}Builder';
     } else {
-      typeStr = type.typeName;
+      typeStr = idlPrefix(type.typeName);
     }
     if (type.isList) {
       return 'List<$typeStr>';
     } else {
       return typeStr;
     }
   }
 
   /**
    * 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;
         for (Annotation annotation in decl.metadata) {
           if (annotation.arguments == null &&
               annotation.name.name == 'topLevel') {
             isTopLevel = true;
           }
         }
         String doc = _getNodeDoc(lineInfo, decl);
         idlModel.ClassDeclaration cls =
             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 FieldDeclaration) {
-            TypeName type = classMember.fields.type;
+          if (classMember is MethodDeclaration && classMember.isGetter) {
+            TypeName type = classMember.returnType;
+            if (type == null) {
+              throw new Exception('Class member needs a type: $classMember');
+            }
             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`');
             }
             String doc = _getNodeDoc(lineInfo, classMember);
             idlModel.FieldType fieldType =
                 new idlModel.FieldType(type.name.name, isList);
-            for (VariableDeclaration field in classMember.fields.variables) {
-              cls.fields.add(new idlModel.FieldDeclaration(
-                  doc, field.name.name, fieldType));
-            }
+            cls.fields.add(new idlModel.FieldDeclaration(
+                doc, classMember.name.name, fieldType));
+          } 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);
         idlModel.EnumDeclaration enm =
             new idlModel.EnumDeclaration(doc, decl.name.name);
         _idl.enums[enm.name] = enm;
         for (EnumConstantDeclaration constDecl in decl.constants) {
           String doc = _getNodeDoc(lineInfo, constDecl);
           enm.values
               .add(new idlModel.EnumValueDeclaration(doc, constDecl.name.name));
         }
       } else if (decl is TopLevelVariableDeclaration) {
         // Ignore top level variable declarations; they are present just to make
         // the IDL analyze without warnings.
       } else {
         throw new Exception('Unexpected declaration `$decl`');
       }
     }
   }
 
   /**
+   * Add the prefix `idl.` to a type name, unless that type name is the name of
+   * a built-in type.
+   */
+  String idlPrefix(String s) {
+    switch (s) {
+      case 'bool':
+      case 'double':
+      case 'int':
+      case 'String':
+        return s;
+      default:
+        return 'idl.$s';
+    }
+  }
+
+  /**
    * Execute [callback] with two spaces added to [_indentation].
    */
   void indent(void callback()) {
     String oldIndentation = _indentation;
     try {
       _indentation += '  ';
       callback();
     } finally {
       _indentation = oldIndentation;
     }
@@ skipping 26 matching lines @@
     checkIdl();
     out('// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file');
     out('// for details. All rights reserved. Use of this source code is governed by a');
     out('// BSD-style license that can be found in the LICENSE file.');
     out('//');
     out('// This file has been automatically generated.  Please do not edit it manually.');
     out('// To regenerate the file, use the script "pkg/analyzer/tool/generate_files".');
     out();
     out('library analyzer.src.summary.format;');
     out();
-    out("import 'base.dart' as base;");
     out("import 'flat_buffers.dart' as fb;");
+    out("import 'idl.dart' as idl;");
     out();
     for (idlModel.EnumDeclaration enm in _idl.enums.values) {
-      _generateEnum(enm);
-      out();
       _generateEnumReader(enm);
       out();
     }
     for (idlModel.ClassDeclaration cls in _idl.classes.values) {
       _generateBuilder(cls);
       out();
-      _generateInterface(cls);
-      out();
+      if (cls.isTopLevel) {
+        _generateReadFunction(cls);
+        out();
+      }
       _generateReader(cls);
       out();
       _generateImpl(cls);
       out();
       _generateMixin(cls);
       out();
     }
   }
 
   /**
    * Enclose [s] in quotes, escaping as necessary.
    */
   String quoted(String s) {
     return JSON.encode(s);
   }
 
   void _generateBuilder(idlModel.ClassDeclaration cls) {
     String name = cls.name;
     String builderName = name + 'Builder';
     String mixinName = '_${name}Mixin';
     List<String> constructorParams = <String>[];
     out('class $builderName extends Object with $mixinName '
-        'implements $name {');
+        'implements ${idlPrefix(name)} {');
     indent(() {
       out('bool _finished = false;');
       // Generate fields.
       out();
       for (idlModel.FieldDeclaration field in cls.fields) {
         String fieldName = field.name;
         idlModel.FieldType type = field.type;
         String typeStr = encodedType(type);
         out('$typeStr _$fieldName;');
       }
@@ skipping 138 matching lines @@
           });
           out('}');
         });
         out('return fbBuilder.endTable();');
       });
       out('}');
     });
     out('}');
   }
 
-  void _generateEnum(idlModel.EnumDeclaration enm) {
-    String name = enm.name;
-    outDoc(enm.documentation);
-    out('enum $name {');
-    indent(() {
-      for (idlModel.EnumValueDeclaration value in enm.values) {
-        outDoc(value.documentation);
-        if (enm.values.last == value) {
-          out('${value.name}');
-        } else {
-          out('${value.name},');
-          out();
-        }
-      }
-    });
-    out('}');
-  }
-
   void _generateEnumReader(idlModel.EnumDeclaration enm) {
     String name = enm.name;
     String readerName = '_${name}Reader';
-    out('class $readerName extends fb.Reader<$name> {');
+    out('class $readerName extends fb.Reader<${idlPrefix(name)}> {');
     indent(() {
       out('const $readerName() : super();');
       out();
       out('@override');
       out('int get size => 4;');
       out();
       out('@override');
-      out('$name read(fb.BufferPointer bp) {');
+      out('${idlPrefix(name)} read(fb.BufferPointer bp) {');
       indent(() {
         out('int index = const fb.Uint32Reader().read(bp);');
-        out('return $name.values[index];');
+        out('return ${idlPrefix(name)}.values[index];');
       });
       out('}');
     });
     out('}');
   }
 
   void _generateImpl(idlModel.ClassDeclaration cls) {
     String name = cls.name;
     String implName = '_${name}Impl';
     String mixinName = '_${name}Mixin';
-    out('class $implName extends Object with $mixinName implements $name {');
+    out('class $implName extends Object with $mixinName'
+        ' implements ${idlPrefix(name)} {');
     indent(() {
       out('final fb.BufferPointer _bp;');
       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) {
         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)';
           } else if (typeName == 'double') {
             readCode = 'const fb.Float64ListReader()';
           } else if (typeName == 'String') {
             String itemCode = 'const fb.StringReader()';
             readCode = 'const fb.ListReader<String>($itemCode)';
           } else if (_idl.classes.containsKey(typeName)) {
-            String itemCode = '$typeName>(const _${typeName}Reader()';
-            readCode = 'const fb.ListReader<$itemCode)';
+            String itemCode = 'const _${typeName}Reader()';
+            readCode = 'const fb.ListReader<${idlPrefix(typeName)}>($itemCode)';
           } else {
             assert(_idl.enums.containsKey(typeName));
             String itemCode = 'const _${typeName}Reader()';
-            readCode = 'const fb.ListReader<$typeName>($itemCode)';
+            readCode = 'const fb.ListReader<${idlPrefix(typeName)}>($itemCode)';
           }
         } else if (typeName == 'bool') {
           readCode = 'const fb.BoolReader()';
         } else if (typeName == 'int') {
           readCode = 'const fb.Uint32Reader()';
         } else if (typeName == 'String') {
           readCode = 'const fb.StringReader()';
         } else if (_idl.enums.containsKey(typeName)) {
           readCode = 'const _${typeName}Reader()';
         } else if (_idl.classes.containsKey(typeName)) {
           readCode = 'const _${typeName}Reader()';
         }
         assert(readCode != null);
         // Write the getter implementation.
         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 _generateInterface(idlModel.ClassDeclaration cls) {
-    String name = cls.name;
-    outDoc(cls.documentation);
-    out('abstract class $name extends base.SummaryClass {');
-    indent(() {
-      if (cls.isTopLevel) {
-        out('factory $name.fromBuffer(List<int> buffer) {');
-        indent(() {
-          out('fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);');
-          out('return const _${name}Reader().read(rootRef);');
-        });
-        out('}');
-      }
-      cls.fields.asMap().forEach((index, field) {
-        String fieldName = field.name;
-        idlModel.FieldType type = field.type;
-        out();
-        outDoc(field.documentation);
-        out('${dartType(type)} get $fieldName;');
-      });
-    });
-    out('}');
-  }
-
   void _generateMixin(idlModel.ClassDeclaration cls) {
     String name = cls.name;
     String mixinName = '_${name}Mixin';
-    out('abstract class $mixinName implements $name {');
+    out('abstract class $mixinName implements ${idlPrefix(name)} {');
     indent(() {
       // Write toMap().
       out('@override');
       out('Map<String, Object> toMap() => {');
       indent(() {
         for (idlModel.FieldDeclaration field in cls.fields) {
           String fieldName = field.name;
           out('${quoted(fieldName)}: $fieldName,');
         }
       });
       out('};');
     });
     out('}');
   }
 
   void _generateReader(idlModel.ClassDeclaration cls) {
     String name = cls.name;
     String readerName = '_${name}Reader';
     String implName = '_${name}Impl';
     out('class $readerName extends fb.TableReader<$implName> {');
     indent(() {
       out('const $readerName();');
       out();
       out('@override');
       out('$implName createObject(fb.BufferPointer bp) => new $implName(bp);');
     });
     out('}');
   }
 
+  void _generateReadFunction(idlModel.ClassDeclaration cls) {
+    String name = cls.name;
+    out('${idlPrefix(name)} read$name(List<int> buffer) {');
+    indent(() {
+      out('fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);');
+      out('return const _${name}Reader().read(rootRef);');
+    });
+    out('}');
+  }
+
   /**
    * Return the documentation text of the given [node], or `null` if the [node]
    * does not have a comment.  Each line is `\n` separated.
    */
   String _getNodeDoc(LineInfo lineInfo, AnnotatedNode node) {
     Comment comment = node.documentationComment;
     if (comment != null &&
         comment.isDocumentation &&
         comment.tokens.length == 1 &&
         comment.tokens.first.type == TokenType.MULTI_LINE_COMMENT) {
       Token token = comment.tokens.first;
       int column = lineInfo.getLocation(token.offset).columnNumber;
       String indent = ' ' * (column - 1);
       return token.lexeme.split('\n').map((String line) {
         if (line.startsWith(indent)) {
           line = line.substring(indent.length);
         }
         return line;
       }).join('\n');
     }
     return null;
   }
 }