Add a data structure to keep track of modifiers in AstBuilder.

pkg/front_end/lib/src/fasta/analyzer/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' as analyzer show Token;
@@ skipping 361 matching lines @@
     }
     push(variable);
     scope[variable.name.name] = variable.name.staticElement =
         new AnalyzerLocalVariableElemment(variable);
   }
 
   void endVariablesDeclaration(int count, Token endToken) {
     debugEvent("VariablesDeclaration");
     List<VariableDeclaration> variables = popList(count);
     TypeName type = pop();
-    pop(); // Modifiers.
+    pop(); // TODO(paulberry): Modifiers.
     push(ast.variableDeclarationStatement(
         ast.variableDeclarationList(null, null, null, type, variables),
         toAnalyzerToken(endToken)));
   }
 
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression rhs = pop();
     Expression lhs = pop();
     push(ast.assignmentExpression(lhs, toAnalyzerToken(token), rhs));
@@ skipping 170 matching lines @@
     AstNode nameOrFunctionTypedParameter = pop();
 
     FormalParameter node;
     SimpleIdentifier name;
     if (nameOrFunctionTypedParameter is FormalParameter) {
       node = nameOrFunctionTypedParameter;
       name = nameOrFunctionTypedParameter.identifier;
     } else {
       name = nameOrFunctionTypedParameter;
       TypeName type = pop();
-      Token keyword = _popOptionalSingleModifier();
+      _Modifiers modifiers = pop();
+      Token keyword = modifiers?.finalConstOrVarKeyword;
       pop(); // TODO(paulberry): Metadata.
       if (thisKeyword == null) {
         node = ast.simpleFormalParameter2(
             covariantKeyword: toAnalyzerToken(covariantKeyword),
             keyword: toAnalyzerToken(keyword),
             type: type,
             identifier: name);
       } else {
         // TODO(scheglov): Ideally the period token should be passed in.
         Token period = identical('.', thisKeyword.next?.stringValue)
@@ skipping 22 matching lines @@
   void endFunctionTypedFormalParameter(
       Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
     debugEvent("FunctionTypedFormalParameter");
 
     FormalParameterList formalParameters = pop();
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
     TypeName returnType = pop();
 
     {
-      List<Token> modifiers = pop();
-      if (modifiers.isNotEmpty) {
+      _Modifiers modifiers = pop();
+      if (modifiers != null) {
         // TODO(scheglov): Report error.
         internalError('Unexpected modifier. Report an error.');
       }
     }
 
     pop(); // TODO(paulberry): Metadata.
 
     FormalParameter node;
     if (thisKeyword == null) {
       node = ast.functionTypedFormalParameter2(
@@ skipping 128 matching lines @@
     push(ast.postfixExpression(pop(), toAnalyzerToken(token)));
   }
 
   void handleModifier(Token token) {
     debugEvent("Modifier");
     push(token);
   }
 
   void handleModifiers(int count) {
     debugEvent("Modifiers");
-    push(popList(count) ?? const <Token>[]);
+    if (count == 0) {
+      push(NullValue.Modifiers);
+    } else {
+      push(new _Modifiers(popList(count)));
+    }
   }
 
   FunctionBody _endFunctionBody() {
     AstNode body = pop();
     // TODO(paulberry): asyncMarker should have a type that allows constructing
     // the necessary analyzer AST data structures.
     AsyncMarker asyncMarker = pop();
     assert(asyncMarker == AsyncMarker.Sync);
     analyzer.Token asyncKeyword = null;
     analyzer.Token star = null;
@@ skipping 12 matching lines @@
   void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
     // TODO(paulberry): set up scopes properly to resolve parameters and type
     // variables.
     debugEvent("TopLevelMethod");
     FunctionBody body = _endFunctionBody();
     FormalParameterList parameters = pop();
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
     analyzer.Token propertyKeyword = toAnalyzerToken(getOrSet);
     TypeAnnotation returnType = pop();
-    Token externalKeyword = _popOptionalSingleModifier();
+    _Modifiers modifiers = pop();
+    Token externalKeyword = modifiers?.externalKeyword;
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     push(ast.functionDeclaration(
         comment,
         metadata,
         toAnalyzerToken(externalKeyword),
         returnType,
         propertyKeyword,
         name,
@@ skipping 166 matching lines @@
           toAnalyzerToken(extendsKeyword), supertype.supertype);
       withClause = ast.withClause(
           toAnalyzerToken(supertype.withKeyword), supertype.mixinTypes);
     } else {
       internalError('Unexpected kind of supertype ${supertype.runtimeType}');
     }
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
     assert(className == name.name);
     className = null;
-    Token abstractKeyword = _popOptionalSingleModifier();
+    _Modifiers modifiers = pop();
+    Token abstractKeyword = modifiers?.abstractKeyword;
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     push(ast.classDeclaration(
         comment,
         metadata,
         toAnalyzerToken(abstractKeyword),
         toAnalyzerToken(classKeyword),
         name,
         typeParameters,
@@ skipping 27 matching lines @@
           ast.implementsClause(toAnalyzerToken(implementsKeyword), interfaces);
     }
     _MixinApplication mixinApplication = pop();
     var superclass = mixinApplication.supertype;
     var withClause = ast.withClause(
         toAnalyzerToken(mixinApplication.withKeyword),
         mixinApplication.mixinTypes);
     analyzer.Token equals = toAnalyzerToken(equalsToken);
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
-    Token abstractKeyword = _popOptionalSingleModifier();
+    _Modifiers modifiers = pop();
+    Token abstractKeyword = modifiers?.abstractKeyword;
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     push(ast.classTypeAlias(
         comment,
         metadata,
         toAnalyzerToken(classKeyword),
         name,
         typeParameters,
         equals,
@@ skipping 85 matching lines @@
     Expression initializer = pop();
     SimpleIdentifier name = pop();
     push(ast.variableDeclaration(
         name, toAnalyzerToken(assignment), initializer));
   }
 
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     debugEvent("TopLevelFields");
     List<VariableDeclaration> variables = popList(count);
     TypeAnnotation type = pop();
-    Token keyword = _popOptionalSingleModifier();
+    _Modifiers modifiers = pop();
+    Token keyword = modifiers?.finalConstOrVarKeyword;
     var variableList = ast.variableDeclarationList(
         null, null, toAnalyzerToken(keyword), type, variables);
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     push(ast.topLevelVariableDeclaration(
         comment, metadata, variableList, toAnalyzerToken(endToken)));
   }
 
   @override
@@ skipping 24 matching lines @@
   void endMethod(Token getOrSet, Token beginToken, Token endToken) {
     debugEvent("Method");
     FunctionBody body = _endFunctionBody();
     ConstructorName redirectedConstructor = null; // TODO(paulberry)
     List<ConstructorInitializer> initializers = null; // TODO(paulberry)
     Token separator = null; // TODO(paulberry)
     FormalParameterList parameters = pop();
     TypeParameterList typeParameters = pop(); // TODO(paulberry)
     var name = pop();
     TypeAnnotation returnType = pop(); // TODO(paulberry)
-    Token modifierKeyword = null; // TODO(paulberry)
-    Token externalKeyword = null;
-    Token constKeyword = null;
-    Token factoryKeyword = null;
-    List<Token> modifiers = pop();
-    for (Token modifier in modifiers) {
-      String value = modifier.stringValue;
-      if (identical('external', value)) {
-        // TODO(scheglov): Check the order and uniqueness.
-        externalKeyword = modifier;
-      } else if (identical('const', value)) {
-        // TODO(scheglov): Check the order and uniqueness.
-        constKeyword = modifier;
-      } else if (identical('factory', value)) {
-        // TODO(scheglov): Check the order and uniqueness.
-        factoryKeyword = modifier;
-      } else {
-        // TODO(scheglov): Report error.
-        internalError("Invalid modifier ($value). Report an error.");
-      }
-    }
-
+    _Modifiers modifiers = pop();
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     Token period;
     void unnamedConstructor(
         SimpleIdentifier returnType, SimpleIdentifier name) {
       push(ast.constructorDeclaration(
           comment,
           metadata,
-          toAnalyzerToken(externalKeyword),
-          toAnalyzerToken(constKeyword),
-          toAnalyzerToken(factoryKeyword),
+          toAnalyzerToken(modifiers?.externalKeyword),
+          toAnalyzerToken(modifiers?.finalConstOrVarKeyword),
+          null, // TODO(paulberry): factoryKeyword
           returnType,
           toAnalyzerToken(period),
           name,
           parameters,
           toAnalyzerToken(separator),
           initializers,
           redirectedConstructor,
           body));
     }
 
     void method(Token operatorKeyword, SimpleIdentifier name) {
       push(ast.methodDeclaration(
           comment,
           metadata,
-          toAnalyzerToken(externalKeyword),
-          toAnalyzerToken(modifierKeyword),
+          toAnalyzerToken(modifiers?.externalKeyword),
+          toAnalyzerToken(
+              modifiers?.abstractKeyword ?? modifiers?.staticKeyword),
           returnType,
           toAnalyzerToken(getOrSet),
           toAnalyzerToken(operatorKeyword),
           name,
           typeParameters,
           parameters,
           body));
     }
 
     if (name is SimpleIdentifier) {
@@ skipping 99 matching lines @@
     push(ast.typeArgumentList(
         toAnalyzerToken(beginToken), arguments, toAnalyzerToken(endToken)));
   }
 
   @override
   void endFields(
       int count, Token covariantKeyword, Token beginToken, Token endToken) {
     debugEvent("Fields");
     List<VariableDeclaration> variables = popList(count);
     TypeAnnotation type = pop();
-    List<Token> modifiers = pop();
-    Token staticKeyword;
-    Token keyword;
-    for (Token modifier in modifiers) {
-      String value = modifier.stringValue;
-      if (identical('static', value)) {
-        // TODO(paulberry): Check the order and uniqueness.
-        staticKeyword = modifier;
-      } else if (identical('var', value)) {
-        // TODO(paulberry): Check the order and uniqueness.
-        keyword = modifier;
-      } else {
-        // TODO(paulberry): Report error.
-        internalError("Invalid modifier ($value). Report an error.");
-      }
-    }
-    var variableList = ast.variableDeclarationList(
-        null, null, toAnalyzerToken(keyword), type, variables);
+    _Modifiers modifiers = pop();
+    var variableList = ast.variableDeclarationList(null, null,
+        toAnalyzerToken(modifiers?.finalConstOrVarKeyword), type, variables);
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     push(ast.fieldDeclaration2(
         comment: comment,
         metadata: metadata,
         covariantKeyword: toAnalyzerToken(covariantKeyword),
-        staticKeyword: toAnalyzerToken(staticKeyword),
+        staticKeyword: toAnalyzerToken(modifiers?.staticKeyword),
         fieldList: variableList,
         semicolon: toAnalyzerToken(endToken)));
   }
 
   @override
   void handleOperatorName(Token operatorKeyword, Token token) {
     debugEvent("OperatorName");
     push(new _OperatorName(operatorKeyword,
         ast.simpleIdentifier(toAnalyzerToken(token), isDeclaration: true)));
   }
 
-  /**
-   * Pop the modifiers list, if the list is empty return `null`, if the list
-   * has one item return it; otherwise return `null`.
-   */
-  Token _popOptionalSingleModifier() {
-    List<Token> modifiers = pop();
-    if (modifiers.length == 0) {
-      return null;
-    } else if (modifiers.length == 1) {
-      // TODO(scheglov): Verify that the modifier is valid.
-      return modifiers[0];
-    } else {
-      // TODO(scheglov): Report error.
-      internalError("Invalid modifier. Report an error.");
-      return null;
-    }
-  }
-
   ParameterKind _toAnalyzerParameterKind(FormalParameterType type) {
     if (type == FormalParameterType.POSITIONAL) {
       return ParameterKind.POSITIONAL;
     } else if (type == FormalParameterType.NAMED) {
       return ParameterKind.NAMED;
     } else {
       return ParameterKind.REQUIRED;
     }
   }
 }
@@ skipping 49 matching lines @@
 }
 
 /// Data structure placed on the stack to represent the keyword "operator"
 /// followed by a token.
 class _OperatorName {
   final Token operatorKeyword;
   final SimpleIdentifier name;
 
   _OperatorName(this.operatorKeyword, this.name);
 }
+
+/// Data structure placed on the stack to represent a non-empty sequence
+/// of modifiers.
+class _Modifiers {
+  Token abstractKeyword;
+  Token externalKeyword;
+  Token finalConstOrVarKeyword;
+  Token staticKeyword;
+
+  _Modifiers(List<Token> modifierTokens) {
+    // No need to check the order and uniqueness of the modifiers, or that
+    // disallowed modifiers are not used; the parser should do that.
+    // TODO(paulberry,ahe): implement the necessary logic in the parser.
+    for (var token in modifierTokens) {
+      var s = token.value;
+      if (identical('abstract', s)) {
+        abstractKeyword = token;
+      } else if (identical('const', s)) {
+        finalConstOrVarKeyword = token;
+      } else if (identical('external', s)) {
+        externalKeyword = token;
+      } else if (identical('final', s)) {
+        finalConstOrVarKeyword = token;
+      } else if (identical('static', s)) {
+        staticKeyword = token;
+      } else if (identical('var', s)) {
+        finalConstOrVarKeyword = token;
+      } else {
+        internalError('Unhandled modifier: $s');
+      }
+    }
+  }
+}