refactor AstBuilder

pkg/analyzer/lib/src/fasta/ast_builder.dart

 // Copyright (c) 2016, 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.
 
 library fasta.analyzer.ast_builder;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
 import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 19 matching lines @@
     show JumpTargetKind, NullValue, ScopeListener;
 import 'package:analyzer/src/dart/error/syntactic_errors.dart';
 
 class AstBuilder extends ScopeListener {
   final AstFactory ast = standard.astFactory;
 
   final ErrorReporter errorReporter;
   final KernelLibraryBuilder library;
   final Builder member;
 
+  ScriptTag scriptTag;
+  final List<Directive> directives = <Directive>[];
+  final List<CompilationUnitMember> declarations = <CompilationUnitMember>[];
+
   @override
   final Uri uri;
 
   /**
    * The [Parser] that uses this listener, used to parse optional parts, e.g.
    * `native` support.
    */
   Parser parser;
 
   bool parseGenericMethodComments = false;
@@ skipping 113 matching lines @@
         }
       }
       elements.add(ast.interpolationString(
           last, unescapeLastStringPart(last.lexeme, quote)));
       push(ast.stringInterpolation(elements));
     }
   }
 
   void handleScript(Token token) {
     debugEvent("Script");
-    push(ast.scriptTag(token));
+    scriptTag = ast.scriptTag(token);
   }
 
   void handleStringJuxtaposition(int literalCount) {
     debugEvent("StringJuxtaposition");
     push(ast.adjacentStrings(popList(literalCount)));
   }
 
   void endArguments(int count, Token beginToken, Token endToken) {
     debugEvent("Arguments");
     List expressions = popList(count);
@@ skipping 917 matching lines @@
     FunctionBody body = pop();
     FormalParameterList parameters = pop();
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
     Token propertyKeyword = getOrSet;
     TypeAnnotation returnType = pop();
     _Modifiers modifiers = pop();
     Token externalKeyword = modifiers?.externalKeyword;
     List<Annotation> metadata = pop();
     Comment comment = pop();
-    push(ast.functionDeclaration(
+    declarations.add(ast.functionDeclaration(
         comment,
         metadata,
         externalKeyword,
         returnType,
         propertyKeyword,
         name,
         ast.functionExpression(typeParameters, parameters, body)));
   }
 
   @override
   void endTopLevelDeclaration(Token token) {
     debugEvent("TopLevelDeclaration");
   }
 
   @override
   void handleInvalidTopLevelDeclaration(Token endToken) {
     debugEvent("InvalidTopLevelDeclaration");
     pop(); // metadata star
     // TODO(danrubel): consider creating a AST node
     // representing the invalid declaration to better support code completion,
     // quick fixes, etc, rather than discarding the metadata and token
-    push(NullValue.InvalidTopLevelDeclaration);
   }
 
   @override
   void beginCompilationUnit(Token token) {
     push(token);
   }
 
   @override
   void endCompilationUnit(int count, Token endToken) {
     debugEvent("CompilationUnit");
-    List<Object> elements = popList(count);
     Token beginToken = pop();
-
-    ScriptTag scriptTag = null;
-    var directives = <Directive>[];
-    var declarations = <CompilationUnitMember>[];
-    if (elements != null) {
-      for (AstNode node in elements) {
-        if (node is ScriptTag) {
-          scriptTag = node;
-        } else if (node is Directive) {
-          directives.add(node);
-        } else if (node is CompilationUnitMember) {
-          declarations.add(node);
-        } else if (node == NullValue.InvalidTopLevelDeclaration) {
-          // TODO(danrubel): consider creating a AST node
-          // representing the invalid declaration
-          // to better support code completion, quick fixes, etc,
-          // rather than discarding the metadata and token
-        } else {
-          unhandled(
-              "${node.runtimeType}", "compilation unit", node?.offset, uri);
-        }
-      }
-    }
+    checkEmpty(endToken.charOffset);
 
     push(ast.compilationUnit(
         beginToken, scriptTag, directives, declarations, endToken));
   }
 
   void endImport(Token importKeyword, Token deferredKeyword, Token asKeyword,
       Token semicolon) {
     debugEvent("Import");
     List<Combinator> combinators = pop();
     SimpleIdentifier prefix;
     if (asKeyword != null) prefix = pop();
     List<Configuration> configurations = pop();
     StringLiteral uri = pop();
     List<Annotation> metadata = pop();
     assert(metadata == null); // TODO(paulberry): fix.
     Comment comment = pop();
-    push(ast.importDirective(
+    directives.add(ast.importDirective(
         comment,
         metadata,
         importKeyword,
         uri,
         configurations,
         deferredKeyword,
         asKeyword,
         prefix,
         combinators,
         semicolon));
   }
 
   void endExport(Token exportKeyword, Token semicolon) {
     debugEvent("Export");
     List<Combinator> combinators = pop();
     List<Configuration> configurations = pop();
     StringLiteral uri = pop();
     List<Annotation> metadata = pop();
     assert(metadata == null);
     Comment comment = pop();
-    push(ast.exportDirective(comment, metadata, exportKeyword, uri,
+    directives.add(ast.exportDirective(comment, metadata, exportKeyword, uri,
         configurations, combinators, semicolon));
   }
 
   @override
   void endDottedName(int count, Token firstIdentifier) {
     debugEvent("DottedName");
     List<SimpleIdentifier> components = popList(count);
     push(ast.dottedName(components));
   }
 
@@ skipping 110 matching lines @@
           extendsKeyword.charOffset, uri);
     }
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
     assert(className == name.name);
     className = null;
     _Modifiers modifiers = pop();
     Token abstractKeyword = modifiers?.abstractKeyword;
     List<Annotation> metadata = pop();
     Comment comment = pop();
-    push(ast.classDeclaration(
+    declarations.add(ast.classDeclaration(
         comment,
         metadata,
         abstractKeyword,
         classKeyword,
         name,
         typeParameters,
         extendsClause,
         withClause,
         implementsClause,
         body.beginToken,
@@ skipping 22 matching lines @@
     var superclass = mixinApplication.supertype;
     var withClause = ast.withClause(
         mixinApplication.withKeyword, mixinApplication.mixinTypes);
     Token equals = equalsToken;
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
     _Modifiers modifiers = pop();
     Token abstractKeyword = modifiers?.abstractKeyword;
     List<Annotation> metadata = pop();
     Comment comment = pop();
-    push(ast.classTypeAlias(
+    declarations.add(ast.classTypeAlias(
         comment,
         metadata,
         classKeyword,
         name,
         typeParameters,
         equals,
         abstractKeyword,
         superclass,
         withClause,
         implementsClause,
         endToken));
   }
 
   @override
   void endLabeledStatement(int labelCount) {
     debugEvent("LabeledStatement");
     Statement statement = pop();
     List<Label> labels = popList(labelCount);
     push(ast.labeledStatement(labels, statement));
   }
 
   @override
   void endLibraryName(Token libraryKeyword, Token semicolon) {
     debugEvent("LibraryName");
     List<SimpleIdentifier> libraryName = pop();
     var name = ast.libraryIdentifier(libraryName);
     List<Annotation> metadata = pop();
     Comment comment = pop();
-    push(ast.libraryDirective(
+    directives.add(ast.libraryDirective(
         comment, metadata, libraryKeyword, name, semicolon));
   }
 
   @override
   void handleQualified(Token period) {
     SimpleIdentifier identifier = pop();
     var prefix = pop();
     if (prefix is List) {
       // We're just accumulating components into a list.
       prefix.add(identifier);
       push(prefix);
     } else if (prefix is SimpleIdentifier) {
       // TODO(paulberry): resolve [identifier].  Note that BodyBuilder handles
       // this situation using SendAccessor.
       push(ast.prefixedIdentifier(prefix, period, identifier));
     } else {
       // TODO(paulberry): implement.
       logEvent('Qualified with >1 dot');
     }
   }
 
   @override
   void endPart(Token partKeyword, Token semicolon) {
     debugEvent("Part");
     StringLiteral uri = pop();
     List<Annotation> metadata = pop();
     Comment comment = pop();
-    push(ast.partDirective(comment, metadata, partKeyword, uri, semicolon));
+    directives
+        .add(ast.partDirective(comment, metadata, partKeyword, uri, semicolon));
   }
 
   @override
   void endPartOf(Token partKeyword, Token semicolon, bool hasName) {
     debugEvent("PartOf");
     List<SimpleIdentifier> libraryName = pop();
     var name = ast.libraryIdentifier(libraryName);
     StringLiteral uri = null; // TODO(paulberry)
     // TODO(paulberry,ahe): seems hacky.  It would be nice if the parser passed
     // in a reference to the "of" keyword.
     var ofKeyword = partKeyword.next;
     List<Annotation> metadata = pop();
     Comment comment = pop();
-    push(ast.partOfDirective(
+    directives.add(ast.partOfDirective(
         comment, metadata, partKeyword, ofKeyword, uri, name, semicolon));
   }
 
   @override
   void endFunctionExpression(Token beginToken, Token token) {
     // TODO(paulberry): set up scopes properly to resolve parameters and type
     // variables.  Note that this is tricky due to the handling of initializers
     // in constructors, so the logic should be shared with BodyBuilder as much
     // as possible.
     debugEvent("FunctionExpression");
@@ skipping 106 matching lines @@
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     debugEvent("TopLevelFields");
     List<VariableDeclaration> variables = popList(count);
     TypeAnnotation type = pop();
     _Modifiers modifiers = pop();
     Token keyword = modifiers?.finalConstOrVarKeyword;
     var variableList =
         ast.variableDeclarationList(null, null, keyword, type, variables);
     List<Annotation> metadata = pop();
     Comment comment = pop();
-    push(ast.topLevelVariableDeclaration(
+    declarations.add(ast.topLevelVariableDeclaration(
         comment, metadata, variableList, endToken));
   }
 
   @override
   void endTypeVariable(Token token, Token extendsOrSuper) {
     // TODO(paulberry): set up scopes properly to resolve parameters and type
     // variables.  Note that this is tricky due to the handling of initializers
     // in constructors, so the logic should be shared with BodyBuilder as much
     // as possible.
     debugEvent("TypeVariable");
@@ skipping 93 matching lines @@
   void endFunctionTypeAlias(
       Token typedefKeyword, Token equals, Token endToken) {
     debugEvent("FunctionTypeAlias");
     if (equals == null) {
       FormalParameterList parameters = pop();
       TypeParameterList typeParameters = pop();
       SimpleIdentifier name = pop();
       TypeAnnotation returnType = pop();
       List<Annotation> metadata = pop();
       Comment comment = pop();
-      push(ast.functionTypeAlias(comment, metadata, typedefKeyword, returnType,
-          name, typeParameters, parameters, endToken));
+      declarations.add(ast.functionTypeAlias(comment, metadata, typedefKeyword,
+          returnType, name, typeParameters, parameters, endToken));
     } else {
       TypeAnnotation type = pop();
       TypeParameterList templateParameters = pop();
       SimpleIdentifier name = pop();
       List<Annotation> metadata = pop();
       Comment comment = pop();
       if (type is! GenericFunctionType) {
         // TODO(paulberry) Generate an error and recover (better than
         // this).
         type = null;
       }
-      push(ast.genericTypeAlias(comment, metadata, typedefKeyword, name,
-          templateParameters, equals, type, endToken));
+      declarations.add(ast.genericTypeAlias(comment, metadata, typedefKeyword,
+          name, templateParameters, equals, type, endToken));
     }
   }
 
   @override
   void endEnum(Token enumKeyword, Token endBrace, int count) {
     debugEvent("Enum");
     List<EnumConstantDeclaration> constants = popList(count);
     // TODO(paulberry,ahe): the parser should pass in the openBrace token.
     var openBrace = enumKeyword.next.next as analyzer.BeginToken;
     // TODO(paulberry): what if the '}' is missing and the parser has performed
     // error recovery?
     Token closeBrace = openBrace.endGroup;
     SimpleIdentifier name = pop();
     List<Annotation> metadata = pop();
     Comment comment = pop();
-    push(ast.enumDeclaration(comment, metadata, enumKeyword, name, openBrace,
-        constants, closeBrace));
+    declarations.add(ast.enumDeclaration(comment, metadata, enumKeyword, name,
+        openBrace, constants, closeBrace));
   }
 
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
     debugEvent("TypeArguments");
     List<TypeAnnotation> arguments = popList(count);
     push(ast.typeArgumentList(beginToken, arguments, endToken));
   }
 
   @override
@@ skipping 12 matching lines @@
         metadata: metadata,
         covariantKeyword: covariantKeyword,
         staticKeyword: modifiers?.staticKeyword,
         fieldList: variableList,
         semicolon: endToken));
   }
 
   @override
   AstNode finishFields() {
     debugEvent("finishFields");
-    return pop();
+    return declarations.removeLast();
   }
 
   @override
   void handleOperatorName(Token operatorKeyword, Token token) {
     debugEvent("OperatorName");
     push(new _OperatorName(
         operatorKeyword, ast.simpleIdentifier(token, isDeclaration: true)));
   }
 
   @override
@@ skipping 258 matching lines @@
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else if (identical('covariant', s)) {
         covariantKeyword = token;
       } else {
         unhandled("$s", "modifier", token.charOffset, null);
       }
     }
   }
 }