report abstract as extraneous modifier

pkg/front_end/lib/src/fasta/parser/parser.dart

 // Copyright (c) 2012, 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.parser.parser;
 
 import '../fasta_codes.dart' show Code, Message, Template;
 
 import '../fasta_codes.dart' as fasta;
 
@@ skipping 2041 matching lines @@
       if (token.type.isBuiltIn) {
         // A built-in identifier can only be a modifier as long as it is
         // followed by another modifier or an identifier. Otherwise, it is the
         // identifier.
         if (token.next.kind != KEYWORD_TOKEN && !token.next.isIdentifier) {
           break;
         }
       }
       int order = modifierOrder(token);
       if (order < 3) {
-        // `abstract` isn't parsed with this method.
         if (order > currentOrder) {
           currentOrder = order;
           if (optional("var", token)) {
             if (!isVarAllowed && parameterKind == null) {
               reportRecoverableErrorWithToken(
                   token, fasta.templateExtraneousModifier);
             }
             switch (typeContinuation ?? TypeContinuation.Required) {
               case TypeContinuation.NormalFormalParameter:
                 typeContinuation =
@@ skipping 69 matching lines @@
                 continue;
             }
           }
           token = parseModifier(token);
           count++;
         } else {
           reportRecoverableErrorWithToken(
               token, fasta.templateExtraneousModifier);
           token = token.next;
         }
+      } else if (order == 3) {
+        // abstract

[ahe, 2017/08/28 11:14:08]

Consider this instead of the comment:

assert(optional("abstract", token))

[danrubel, 2017/08/29 14:58:47]

Good idea. Done.

+        reportRecoverableErrorWithToken(
+            token, fasta.templateExtraneousModifier);

[ahe, 2017/08/28 11:14:08]

Should this be a new error code so it's easier to distinguish them in the
analyzer?

[danrubel, 2017/08/29 14:58:47]

I need to create a separate error code to distinguish 'abstract' on class
members. I'll address that in a separate CL.

+        token = token.next;
       } else {
         break;
       }
     }
     listener.handleModifiers(count);
 
     typeContinuation ??=
         (isVarAllowed || memberKind == MemberKind.GeneralizedFunctionType)
             ? TypeContinuation.Required
             : TypeContinuation.Optional;
@@ skipping 1975 matching lines @@
   }
 
   Token reportUnexpectedToken(Token token) {
     return reportUnrecoverableErrorWithToken(
         token, fasta.templateUnexpectedToken);
   }
 }
 
 // TODO(ahe): Remove when analyzer supports generalized function syntax.
 typedef _MessageWithArgument<T> = Message Function(T);