Support for modifiers.

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:front_end/src/fasta/scanner/token.dart'
     show BeginGroupToken, Token;
 
 import 'package:analyzer/analyzer.dart';
@@ skipping 491 matching lines @@
     push(ast.throwExpression(toAnalyzerToken(throwToken), pop()));
   }
 
   void endFormalParameter(Token thisKeyword) {
     debugEvent("FormalParameter");
     if (thisKeyword != null) {
       internalError("'this' can't be used here.");
     }
     SimpleIdentifier name = pop();
     TypeName type = pop();
-    pop(); // Modifiers.
+    Token keyword = _popOptionalSingleModifier();
     pop(); // Metadata.
     SimpleFormalParameter node = ast.simpleFormalParameter(
-        null, null, toAnalyzerToken(thisKeyword), type, name);
+        null, null, toAnalyzerToken(keyword), type, name);
     scope[name.name] = name.staticElement = new AnalyzerParameterElement(node);
     push(node);
   }
 
   void endFormalParameters(int count, Token beginToken, Token endToken) {
     debugEvent("FormalParameters");
     List<FormalParameter> parameters = popList(count) ?? <FormalParameter>[];
     push(ast.formalParameterList(toAnalyzerToken(beginToken), parameters, null,
         null, toAnalyzerToken(endToken)));
   }
@@ skipping 77 matching lines @@
     push(ast.prefixExpression(toAnalyzerToken(token), pop()));
   }
 
   void handleUnaryPostfixAssignmentExpression(Token token) {
     debugEvent("UnaryPostfixAssignmentExpression");
     push(ast.postfixExpression(pop(), toAnalyzerToken(token)));
   }
 
   void handleModifier(Token token) {
     debugEvent("Modifier");
-    // TODO(ahe): Don't ignore modifiers.
+    push(token);
   }
 
   void handleModifiers(int count) {
     debugEvent("Modifiers");
-    // TODO(ahe): Don't ignore modifiers.
-    push(NullValue.Modifiers);
+    push(popList(count) ?? const <Token>[]);
   }
 
   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();
-    // TODO(paulberry): handle modifiers.
-    var modifiers = pop();
-    assert(modifiers == null);
-    analyzer.Token externalKeyword = null;
+    Token externalKeyword = _popOptionalSingleModifier();
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     push(ast.functionDeclaration(
         comment,
         metadata,
-        externalKeyword,
+        toAnalyzerToken(externalKeyword),
         returnType,
         propertyKeyword,
         name,
         ast.functionExpression(typeParameters, parameters, body)));
   }
 
   @override
   void endTopLevelDeclaration(Token token) {
     debugEvent("TopLevelDeclaration");
   }
@@ skipping 160 matching lines @@
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
     Token classKeyword;
     // TODO(paulberry,ahe): This is a hack.  The parser should give us the class
     // keyword.
     if (optional('abstract', beginToken)) {
       classKeyword = beginToken.next;
     } else {
       classKeyword = beginToken;
     }
-    var modifiers = pop();
-    assert(modifiers == null); // TODO(paulberry)
-    analyzer.Token abstractKeyword;
+    Token abstractKeyword = _popOptionalSingleModifier();
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     push(ast.classDeclaration(
         comment,
         metadata,
-        abstractKeyword,
+        toAnalyzerToken(abstractKeyword),
         toAnalyzerToken(classKeyword),
         name,
         typeParameters,
         extendsClause,
         withClause,
         implementsClause,
         toAnalyzerToken(body.beginToken),
         body.members,
         toAnalyzerToken(body.endToken)));
   }
 
   @override
   void endMixinApplication() {
     debugEvent("MixinApplication");
     List<TypeName> mixinTypes = pop();
     // TODO(paulberry,ahe): the parser doesn't give us enough information to
     // locate the "with" keyword.
     Token withKeyword;
     TypeName supertype = pop();
     push(new _MixinApplication(supertype, withKeyword, mixinTypes));
   }
 
   @override
-  void endNamedMixinApplication(
-      Token beginToken, Token equalsToken, Token implementsKeyword, Token endToken) {
+  void endNamedMixinApplication(Token beginToken, Token equalsToken,
+      Token implementsKeyword, Token endToken) {
     debugEvent("NamedMixinApplication");
     ImplementsClause implementsClause;
     if (implementsKeyword != null) {
       List<TypeName> interfaces = pop();
       implementsClause =
           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 classKeyword;
     // TODO(paulberry,ahe): This is a hack.  The parser should give us the class
     // keyword.
     if (identical(beginToken.value, 'abstract')) {
       classKeyword = beginToken.next;
     } else {
       classKeyword = beginToken;
     }
-    var modifiers = pop();
-    assert(modifiers == null); // TODO(paulberry)
-    analyzer.Token abstractKeyword;
+    Token abstractKeyword = _popOptionalSingleModifier();
     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,
-        abstractKeyword,
+        toAnalyzerToken(abstractKeyword),
         superclass,
         withClause,
         implementsClause,
         toAnalyzerToken(endToken)));
   }
 
   @override
   void beginLibraryName(Token token) {
     accumulateIdentifierComponents = true;
     isFirstIdentifier = true;
@@ skipping 83 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();
-    var keyword;
-    if (optional('var', beginToken) ||
-        optional('const', beginToken) ||
-        optional('final', beginToken)) {
-      keyword = beginToken;
-    }
+    Token keyword = _popOptionalSingleModifier();
     var variableList = ast.variableDeclarationList(
         null, null, toAnalyzerToken(keyword), type, variables);
-    var modifiers = pop();
-    assert(modifiers == null); // TODO(paulberry)
     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
   void endTypeVariable(Token token, Token extendsOrSuper) {
     // TODO(paulberry): set up scopes properly to resolve parameters and type
@@ skipping 23 matching lines @@
     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();
     var name = pop();
     analyzer.Token propertyKeyword = toAnalyzerToken(getOrSet);
     TypeAnnotation returnType = pop();
-    // TODO(paulberry): handle modifiers.
-    var modifiers = pop();
-    assert(modifiers == null);
-    Token externalKeyword = null; // TODO(paulberry)
-    Token constKeyword = null; // TODO(paulberry)
-    Token factoryKeyword = 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.

[Paul Berry, 2017/02/21 23:09:11]

The TODO is good, but for safety, let's also use "internalError" here so that if
we forget to come back and fix this, we won't ever accept invalid programs.

[scheglov, 2017/02/22 03:08:23]

Done.

[ahe, 2017/02/22 09:08:17]

Alternatively, try this:

printUnexpected(uri, modifier.charOffset, "Unexpected modifier: '${value}'.");

Later on, I plan to run through all these text strings and convert them to
proper error messages.

[scheglov, 2017/02/22 16:32:46]

There are 331 usage of internalError() and just 2 usages of printUnexpected() in
the codebase. So, it seems that internalError() is more popular.

[ahe, 2017/02/27 08:39:26]

We talked about the differences between internalError and printUnexpected in a
meeting, but as my memory sometimes plays tricks on me, I've realized that
there's an even better way to report compile-time errors.

internalError is used when the compiler is broken. Here's its documentation:

/// Used to report an internal error.
///
/// Internal errors should be avoided as best as possible, but are preferred
/// over assertion failures. Favor error messages that starts with "Internal
/// error: " and a short description that may help a developer debug the issue.
/// This method should be called instead of using `throw`, as this allows us to
/// ensure that there are no throws anywhere in the codebase.

So that might not be the right thing to use here as it seems you've identified a
compile-time error.

I haven't documented [printUnexpected], and I'll do so, but I've documented
[inputError] which is kinda similar. The latter stops the compilation, that is,
a fatal compile-time error that the compiler can't recover from. Obviously, this
isn't ideal, so I added [printUnexpected], which just prints a compile-time
error.

However, when you're in BodyBuilder or AstBuilder, you always have access to the
current library builder, so you can use LibraryBuilder.addCompileTimeError.

So finally, I can conclude that LibraryBuilder.addCompileTimeError would
probably be the right method to use here :-)

I'll create a CL where I update the documentation.

+      }
+    }
+
     List<Annotation> metadata = pop();
     // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
     Comment comment = null;
     SimpleIdentifier returnType2;
     Token period;
     SimpleIdentifier name2;
     if (name is SimpleIdentifier) {
       SimpleIdentifier returnType2 = name;
     }
     push(ast.constructorDeclaration(
@@ skipping 40 matching lines @@
     push(ast.functionTypeAlias(
         comment,
         metadata,
         toAnalyzerToken(typedefKeyword),
         returnType,
         name,
         typeParameters,
         parameters,
         toAnalyzerToken(endToken)));
   }
+
+  /**
+   * 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.

[Paul Berry, 2017/02/21 23:09:11]

Ditto.

[scheglov, 2017/02/22 03:08:24]

Done.

+      return null;
+    }
+  }
 }
 
 /// Data structure placed on the stack to represent a class body.
 ///
 /// This is needed because analyzer has no separate AST representation of a
 /// class body; it simply stores all of the relevant data in the
 /// [ClassDeclaration] object.
 class _ClassBody {
   final Token beginToken;
 
@@ skipping 12 matching lines @@
 /// [ClassDeclaration] or [ClassTypeAlias] object.
 class _MixinApplication {
   final TypeName supertype;
 
   final Token withKeyword;
 
   final List<TypeName> mixinTypes;
 
   _MixinApplication(this.supertype, this.withKeyword, this.mixinTypes);
 }