Remove peeking from parseTypedef and parseClassOrNamedMixinApplication.

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
         FastaCode,
         FastaMessage,
@@ skipping 162 matching lines @@
 ///
 /// An assertion can legally occur as a statement. However, assertions are also
 /// experimentally allowed in initializers. For improved error recovery, we
 /// also attempt to parse asserts as expressions.
 enum Assert {
   Expression,
   Initializer,
   Statement,
 }
 
+/// Indication of how the parser should continue after (attempting) to parse a
+/// type.
+///
+/// Depending on the continuation, the parser may not parse a type at all.
+enum TypeContinuation {
+  /// Indicates that a type is unconditionally expected.
+  Required,
+
+  /// Indicates that a type may follow. If the following matches one of these
+  /// productions, it is parsed as a type:
+  ///
+  ///  - `'void'`
+  ///  - `'Function' ( '(' | '<' )`
+  ///  - `identifier ('.' identifier)? ('<' ... '>')? identifer`
+  ///
+  /// Otherwise, do nothing.
+  Optional,
+
+  /// Indicates that the keyword `typedef` has just been seen, and the parser
+  /// should parse the following as a type unless it is followed by `=`.
+  Typedef,
+}
+
 /// An event generating parser of Dart programs. This parser expects all tokens
 /// in a linked list (aka a token stream).
 ///
 /// The class [Scanner] is used to generate a token stream. See the file
 /// [scanner.dart](../scanner.dart).
 ///
 /// Subclasses of the class [Listener] are used to listen to events.
 ///
 /// Most methods of this class belong in one of three major categories: parse
 /// methods, peek methods, and skip methods. Parse methods all have the prefix
@@ skipping 415 matching lines @@
 
   Token parseScript(Token token) {
     listener.handleScript(token);
     return token.next;
   }
 
   Token parseTypedef(Token token) {
     Token typedefKeyword = token;
     listener.beginFunctionTypeAlias(token);
     Token equals;
-    if (optional('=', peekAfterNominalType(token.next))) {
+    Token afterType = parseType(token.next, TypeContinuation.Typedef);
+    if (afterType == null) {
       token = parseIdentifier(token.next, IdentifierContext.typedefDeclaration);
       token = parseTypeVariablesOpt(token);
       equals = token;
       token = expect('=', token);
       token = parseType(token);
     } else {
-      token = parseType(token.next, isOptional: true);
+      token = afterType;
       token = parseIdentifier(token, IdentifierContext.typedefDeclaration);
       token = parseTypeVariablesOpt(token);
       token = parseFormalParameters(token, MemberKind.FunctionTypeAlias);
     }
     listener.endFunctionTypeAlias(typedefKeyword, equals, token);
     return expect(';', token);
   }
 
   Token parseMixinApplication(Token token) {
     listener.beginMixinApplication(token);
@@ skipping 325 matching lines @@
         count++;
       }
     }
     Token endBrace = token;
     token = expect('}', token);
     listener.endEnum(enumKeyword, endBrace, count);
     return token;
   }
 
   Token parseClassOrNamedMixinApplication(Token token) {
+    listener.beginClassOrNamedMixinApplication(token);
     Token begin = token;
-    Token abstractKeyword;
+    if (optional('abstract', token)) {
+      token = parseModifier(token);
+      listener.handleModifiers(1);
+    } else {
+      listener.handleModifiers(0);
+    }
     Token classKeyword = token;
-    if (optional('abstract', token)) {
-      abstractKeyword = token;
-      token = token.next;
-      classKeyword = token;
-    }
-    assert(optional('class', classKeyword));
-    int modifierCount = 0;
-    if (abstractKeyword != null) {
-      parseModifier(abstractKeyword);
-      modifierCount++;
-    }
-    listener.handleModifiers(modifierCount);
-    bool isMixinApplication = optional('=', peekAfterNominalType(token));
-    Token name = token.next;
-
-    if (isMixinApplication) {
-      token = parseIdentifier(name, IdentifierContext.namedMixinDeclaration);
+    token = expect("class", token);
+    Token name = token;
+    token =
+        parseIdentifier(name, IdentifierContext.classOrNamedMixinDeclaration);
+    token = parseTypeVariablesOpt(token);
+    if (optional('=', token)) {
       listener.beginNamedMixinApplication(begin, name);
-    } else {
-      token = parseIdentifier(name, IdentifierContext.classDeclaration);
-      listener.beginClassDeclaration(begin, name);
-    }
-
-    token = parseTypeVariablesOpt(token);
-
-    if (optional('=', token)) {
       Token equals = token;
       token = token.next;
       return parseNamedMixinApplication(
           token, begin, classKeyword, name, equals);
     } else {
+      listener.beginClassDeclaration(begin, name);
       return parseClass(token, begin, classKeyword, name);
     }
   }
 
   Token parseNamedMixinApplication(
       Token token, Token begin, Token classKeyword, Token name, Token equals) {
     token = parseMixinApplication(token);
     Token implementsKeyword = null;
     if (optional('implements', token)) {
       implementsKeyword = token;
@@ skipping 117 matching lines @@
   bool notEofOrValue(String value, Token token) {
     return !identical(token.kind, EOF_TOKEN) &&
         !identical(value, token.stringValue);
   }
 
   bool isGeneralizedFunctionType(Token token) {
     return optional('Function', token) &&
         (optional('<', token.next) || optional('(', token.next));
   }
 
-  Token parseType(Token token, {bool isOptional: false}) {
-    if (isOptional) {
-      do {
+  /// Parse a type, if it is appropriate to do so.
+  ///
+  /// If this method can parse a type, it will return the next (non-null) token
+  /// after the type. Otherwise, it returns null.
+  Token parseType(Token token,
+      [TypeContinuation continuation = TypeContinuation.Required]) {
+    switch (continuation) {
+      case TypeContinuation.Typedef:
+        if (optional('=', peekAfterNominalType(token))) {
+          return null; // This isn't a type, it's a new-style typedef.
+        }
+        continue optional;
+
+      optional:
+      case TypeContinuation.Optional:
         if (optional("void", token)) {
           if (isGeneralizedFunctionType(token.next)) {
             // This is a type, parse it.
             break;
           } else {
             listener.handleVoidKeyword(token);
             return token.next;
           }
         } else {
           if (isGeneralizedFunctionType(token)) {
             // Function type without return type, parse it.
             break;
           }
           token = listener.injectGenericCommentTypeAssign(token);
           Token peek = peekAfterIfType(token);
           if (peek != null && (peek.isIdentifier || optional('this', peek))) {
             // This is a type followed by an identifier, parse it.
             break;
           }
           listener.handleNoType(token);
           return token;
         }
-      } while (false);
+        break;
+
+      case TypeContinuation.Required:
+        break;
+
+      default:
+        throw "Internal error: Unhandled continuation '$continuation'.";
     }
     Token begin = token;
     if (isGeneralizedFunctionType(token)) {
       // A function type without return type.
       // Push the non-existing return type first. The loop below will
       // generate the full type.
       listener.handleNoType(token);
     } else if (optional("void", token) &&
         isGeneralizedFunctionType(token.next)) {
       listener.handleVoidKeyword(token);
@@ skipping 214 matching lines @@
     if (externalModifier != null) {
       parseModifier(externalModifier);
       listener.handleModifiers(1);
     } else {
       listener.handleModifiers(0);
     }
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
-      parseType(type, isOptional: true);
+      parseType(type, TypeContinuation.Optional);
     }
     Token token =
         parseIdentifier(name, IdentifierContext.topLevelFunctionDeclaration);
 
     bool isGetter = false;
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       isGetter = optional("get", getOrSet);
       listener.handleNoTypeVariables(token);
@@ skipping 379 matching lines @@
           reportRecoverableErrorCodeWithToken(token, codeExtraneousModifier);
           token = token.next;
         }
       } else {
         break;
       }
     }
     listener.handleModifiers(count);
 
     Token beforeType = token;
-    token = parseType(token, isOptional: returnTypeAllowed || !typeRequired);
+    token = parseType(
+        token,
+        returnTypeAllowed || !typeRequired
+            ? TypeContinuation.Optional
+            : TypeContinuation.Required);
     if (typeRequired && beforeType == token) {
       reportRecoverableErrorCode(token, codeTypeRequired);
     }
     if (hasVar && beforeType != token) {
       reportRecoverableErrorCode(beforeType, codeTypeAfterVar);
     }
     return token;
   }
 
   /// Returns the first token after the type starting at [token].
@@ skipping 284 matching lines @@
         count++;
       }
       listener.handleModifiers(count);
     }
 
     parseModifierList(modifiers);
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
-      parseType(type, isOptional: true);
+      parseType(type, TypeContinuation.Optional);
     }
     Token token;
     if (optional('operator', name)) {
       token = parseOperatorName(name);
       if (staticModifier != null) {
         reportRecoverableErrorCodeWithToken(
             staticModifier, codeExtraneousModifier);
       }
     } else {
       token = parseIdentifier(name, IdentifierContext.methodDeclaration);
@@ skipping 113 matching lines @@
     listener.beginFunctionDeclaration(token);
     token = parseFunction(token);
     listener.endFunctionDeclaration(token);
     return token;
   }
 
   Token parseFunctionExpression(Token token) {
     Token beginToken = token;
     listener.beginFunction(token);
     listener.handleModifiers(0);
-    token = parseType(token, isOptional: true);
+    token = parseType(token, TypeContinuation.Optional);
     listener.beginFunctionName(token);
     token = parseIdentifier(token, IdentifierContext.functionExpressionName);
     listener.endFunctionName(beginToken, token);
     token = parseTypeVariablesOpt(token);
     token = parseFormalParameters(token, MemberKind.Local);
     listener.handleNoInitializers();
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
@@ skipping 1773 matching lines @@
     return reportUnrecoverableError(
         token, () => code.format(uri, token.charOffset, string));
   }
 }
 
 typedef FastaMessage NoArgument(Uri uri, int charOffset);
 
 typedef FastaMessage TokenArgument(Uri uri, int charOffset, Token token);
 
 typedef FastaMessage StringArgument(Uri uri, int charOffset, String string);