Pass 'classKeyword' to endClassDeclaratio() and endNamedMixinApplication().

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 '../scanner.dart' show
     ErrorToken;
 
 import '../scanner/recover.dart' show
@@ skipping 690 matching lines @@
     }
     Token endBrace = token;
     token = expect('}', token);
     listener.endEnum(enumKeyword, endBrace, count);
     return token;
   }
 
   Token parseClassOrNamedMixinApplication(Token token) {
     Token begin = token;
     Token abstractKeyword;
+    Token classKeyword = token;
     if (optional('abstract', token)) {
       abstractKeyword = token;
       token = token.next;
+      classKeyword = token;
     }

[ahe, 2017/02/22 05:48:27]

How about adding

assert(optional("class", classKeyword));

here?

[scheglov, 2017/02/22 06:13:27]

Done.

     int modifierCount = 0;
     if (abstractKeyword != null) {
       parseModifier(abstractKeyword);
       modifierCount++;
     }
     listener.handleModifiers(modifierCount);
     bool isMixinApplication = optional('=', peekAfterType(token));
     Token name = token.next;
     token = parseIdentifier(name);
 
     if (isMixinApplication) {
       listener.beginNamedMixinApplication(begin, name);
     } else {
       listener.beginClassDeclaration(begin, name);
     }
 
     token = parseTypeVariablesOpt(token);
 
     if (optional('=', token)) {
       Token equals = token;
       token = token.next;
-      return parseNamedMixinApplication(token, begin, name, equals);
+      return parseNamedMixinApplication(token, begin, classKeyword, name,
+          equals);
     } else {
-      return parseClass(token, begin, name);
+      return parseClass(token, begin, classKeyword, name);
     }
   }
 
-  Token parseNamedMixinApplication(Token token, Token begin, Token name,
-      Token equals) {
+  Token parseNamedMixinApplication(Token token, Token begin, Token classKeyword,
+      Token name, Token equals) {
     token = parseMixinApplication(token);
     Token implementsKeyword = null;
     if (optional('implements', token)) {
       implementsKeyword = token;
       token = parseTypeList(token.next);
     }
-    listener.endNamedMixinApplication(begin, equals, implementsKeyword, token);
+    listener.endNamedMixinApplication(begin, classKeyword, equals,
+        implementsKeyword, token);
     return expect(';', token);
   }
 
-  Token parseClass(Token token, Token begin, Token name) {
+  Token parseClass(Token token, Token begin, Token classKeyword, Token name) {
     Token extendsKeyword;
     if (optional('extends', token)) {
       extendsKeyword = token;
       if (optional('with', peekAfterType(token.next))) {
         token = parseMixinApplication(token.next);
       } else {
         token = parseType(token.next);
       }
     } else {
       extendsKeyword = null;
       listener.handleNoType(token);
     }
     Token implementsKeyword;
     int interfacesCount = 0;
     if (optional('implements', token)) {
       implementsKeyword = token;
       do {
         token = parseType(token.next);
         ++interfacesCount;
       } while (optional(',', token));
     }
     token = parseClassBody(token);
     listener.endClassDeclaration(
-        interfacesCount, begin, extendsKeyword, implementsKeyword, token);
+        interfacesCount, begin, classKeyword, extendsKeyword,
+        implementsKeyword, token);
     return token.next;
   }
 
   Token parseStringPart(Token token) {
     if (token.kind != STRING_TOKEN) {
       token = reportUnrecoverableError(token, ErrorKind.ExpectedString);
     }
     listener.handleStringPart(token);
     return token.next;
   }
@@ skipping 2528 matching lines @@
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
       return listener.handleUnrecoverableError(token, kind, arguments);
     }
   }
 }