Change summary code generator to use Fasta parser.

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:
  * - A class with the same name which represents deserialized summary data in
  *   memory.  This class has read-only semantics.
  * - A "builder" class which can be used to generate serialized summary data.
  *   This class has write-only semantics.
  *
  * Each of the "builder" classes has a single `finish` method which writes
  * the entity being built into the given FlatBuffer and returns the `Offset`
  * reference to it.
  */
 library analyzer.tool.summary.generate;
 
 import 'dart:convert';
 import 'dart:io' hide File;
 
-import 'package:analyzer/analyzer.dart';
-import 'package:analyzer/dart/ast/token.dart';
-import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/src/codegen/tools.dart';
-import 'package:analyzer/src/dart/scanner/reader.dart';
-import 'package:analyzer/src/dart/scanner/scanner.dart';
-import 'package:analyzer/src/generated/parser.dart';
-import 'package:analyzer/src/generated/source.dart';
+import 'package:front_end/src/fasta/scanner/string_scanner.dart';
+import 'package:front_end/src/fasta/scanner/token.dart';
 import 'package:path/path.dart';
 
 import 'idl_model.dart' as idlModel;
+import 'mini_ast.dart';
 
 main() {
   String script = Platform.script.toFilePath(windows: Platform.isWindows);
   String pkgPath = normalize(join(dirname(script), '..', '..'));
   GeneratedContent.generateAll(pkgPath, allTargets);
 }
 
 final List<GeneratedContent> allTargets = <GeneratedContent>[
   formatTarget,
   schemaTarget
@@ skipping 33 matching lines @@
    * Semantic model of the "IDL" input file.
    */
   idlModel.Idl _idl;
 
   _CodeGenerator(String pkgPath) {
     // Parse the input "IDL" file.
     PhysicalResourceProvider provider = new PhysicalResourceProvider(
         PhysicalResourceProvider.NORMALIZE_EOL_ALWAYS);
     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);
     // Extract a description of the IDL and make sure it is valid.
-    extractIdl(lineInfo, idlParsed);
+    var scanner = new StringScanner(idlText, includeComments: true);
+    var startingToken = scanner.tokenize();
+    var listener = new MiniAstBuilder();
+    var parser = new MiniAstParser(listener);
+    parser.parseUnit(startingToken);
+    extractIdl(listener.compilationUnit);
     checkIdl();
   }
 
   /**
    * 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) {
@@ skipping 101 matching lines @@
       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) {
+  void extractIdl(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;
+        String clsName = decl.name;
         for (Annotation annotation in decl.metadata) {
           if (annotation.arguments != null &&
-              annotation.name.name == 'TopLevel' &&
+              annotation.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 (annotation.arguments.length == 1) {
+              Expression arg = annotation.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) {
+            } else if (annotation.arguments.length != 0) {
               throw new Exception(
                   'Class `$clsName`: TopLevel requires 0 or 1 arguments');
             }
           }
         }
-        String doc = _getNodeDoc(lineInfo, decl);
+        String doc = _getNodeDoc(decl);
         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) {
+        if (decl.superclass == null || decl.superclass.name != expectedBase) {
           throw new Exception(
               'Class `$clsName` needs to extend `$expectedBase`');
         }
         for (ClassMember classMember in decl.members) {
           if (classMember is MethodDeclaration && classMember.isGetter) {
-            String desc = '$clsName.${classMember.name.name}';
-            if (classMember.returnType is! TypeName) {
-              if (classMember.returnType == null) {
-                throw new Exception('Class member needs a type: $desc');
-              }
-              throw new Exception('Class member needs a class type: $desc');
+            String desc = '$clsName.${classMember.name}';
+            if (classMember.returnType == null) {
+              throw new Exception('Class member needs a type: $desc');
             }
             TypeName type = classMember.returnType;
             bool isList = false;
-            if (type.name.name == 'List' &&
+            if (type.name == 'List' &&
                 type.typeArguments != null &&
-                type.typeArguments.arguments.length == 1) {
+                type.typeArguments.length == 1) {
               isList = true;
-              type = type.typeArguments.arguments[0];
+              type = type.typeArguments[0];
             }
             if (type.typeArguments != null) {
               throw new Exception('Cannot handle type arguments in `$type`');
             }
             int id;
             bool isDeprecated = false;
             bool isInformative = false;
             for (Annotation annotation in classMember.metadata) {
-              if (annotation.name.name == 'Id') {
+              if (annotation.name == 'Id') {
                 if (id != null) {
                   throw new Exception(
                       'Duplicate @id annotation ($classMember)');
                 }
-                if (annotation.arguments.arguments.length != 1) {
+                if (annotation.arguments == null) {
+                  throw new Exception('@Id must be passed an argument');
+                }
+                if (annotation.arguments.length != 1) {
                   throw new Exception(
                       '@Id must be passed exactly one argument ($desc)');
                 }
-                Expression expression = annotation.arguments.arguments[0];
+                Expression expression = annotation.arguments[0];
                 if (expression is IntegerLiteral) {
                   id = expression.value;
                 } else {
                   throw new Exception(
                       '@Id parameter must be an integer literal ($desc)');
                 }
-              } else if (annotation.name.name == 'deprecated') {
+              } else if (annotation.name == 'deprecated') {
                 if (annotation.arguments != null) {
                   throw new Exception('@deprecated does not take args ($desc)');
                 }
                 isDeprecated = true;
-              } else if (annotation.name.name == 'informative') {
+              } else if (annotation.name == 'informative') {
                 isInformative = true;
               }
             }
             if (id == null) {
               throw new Exception('Missing @id annotation ($desc)');
             }
-            String doc = _getNodeDoc(lineInfo, classMember);
+            String doc = _getNodeDoc(classMember);
             idlModel.FieldType fieldType =
-                new idlModel.FieldType(type.name.name, isList);
-            cls.allFields.add(new idlModel.FieldDeclaration(
-                doc,
-                classMember.name.name,
-                fieldType,
-                id,
-                isDeprecated,
-                isInformative));
+                new idlModel.FieldType(type.name, isList);
+            cls.allFields.add(new idlModel.FieldDeclaration(doc,
+                classMember.name, fieldType, id, isDeprecated, isInformative));
           } else if (classMember is ConstructorDeclaration &&
-              classMember.name.name == 'fromBuffer') {
+              classMember.name.name.endsWith('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);
+        String doc = _getNodeDoc(decl);
         idlModel.EnumDeclaration enm =
-            new idlModel.EnumDeclaration(doc, decl.name.name);
+            new idlModel.EnumDeclaration(doc, decl.name);
         _idl.enums[enm.name] = enm;
         for (EnumConstantDeclaration constDecl in decl.constants) {
-          String doc = _getNodeDoc(lineInfo, constDecl);
+          String doc = _getNodeDoc(constDecl);
           enm.values
-              .add(new idlModel.EnumValueDeclaration(doc, constDecl.name.name));
+              .add(new idlModel.EnumValueDeclaration(doc, constDecl.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`');
       }
     }
   }
 
   /**
    * Generate a string representing the FlatBuffer schema type which should be
    * used to represent [type].
    */
@@ skipping 647 matching lines @@
         default:
           throw "Don't know how to generate signature call for $typeName";
       }
     }
   }
 
   /**
    * 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) {
+  String _getNodeDoc(AnnotatedNode node) {
     Comment comment = node.documentationComment;
     if (comment != null &&
         comment.isDocumentation &&
         comment.tokens.length == 1 &&
-        comment.tokens.first.type == TokenType.MULTI_LINE_COMMENT) {
+        comment.tokens.first.lexeme.startsWith('/*')) {
       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);
-        }
+        line = line.trimLeft();
+        if (line.startsWith('*')) line = ' ' + line;
         return line;
       }).join('\n');
     }
     return null;
   }
 }