Fix various parser bugs related to modifiers of top-level and class members.

dart/sdk/lib/_internal/compiler/implementation/scanner/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.
 
 part of scanner;
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list (aka a token stream).
  *
@@ skipping 30 matching lines @@
       listener.endTopLevelDeclaration(token);
       count++;
     }
     listener.endCompilationUnit(count, token);
     return token;
   }
 
   Token parseTopLevelDeclaration(Token token) {
     token = parseMetadataStar(token);
     final String value = token.stringValue;
-    if ((identical(value, 'abstract')) || (identical(value, 'class'))) {
+    if ((identical(value, 'abstract') && optional('class', token.next))
+        || identical(value, 'class')) {
       return parseClass(token);
     } else if (identical(value, 'typedef')) {
       return parseTypedef(token);
     } else if (identical(value, 'library')) {
       return parseLibraryName(token);
     } else if (identical(value, 'import')) {
       return parseImport(token);
     } else if (identical(value, 'export')) {
       return parseExport(token);
     } else if (identical(value, 'part')) {
@@ skipping 575 matching lines @@
           isField = true;
         }
         break;
       } else {
         token = listener.unexpected(token);
         if (identical(token.kind, EOF_TOKEN)) return token;
       }
     }
     var modifiers = identifiers.reverse();
     return isField
-        ? parseTopLevelFields(start, modifiers, type, getOrSet, name)
+        ? parseFields(start, modifiers, type, getOrSet, name, true)
         : parseTopLevelMethod(start, modifiers, type, getOrSet, name);
   }
 
-  Token parseTopLevelFields(Token start,
-                            Link<Token> modifiers,
-                            Token type,
-                            Token getOrSet,
-                            Token name) {
+  bool isVarFinalOrConst(Token token) {
+    String value = token.stringValue;
+    return identical('var', value)
+        || identical('final', value)
+        || identical('const', value);
+  }
+
+  Token expectVarFinalOrConst(Link<Token> modifiers,
+                              bool hasType,
+                              bool allowStatic) {
+    int modifierCount = 0;
+    Token staticModifier;
+    if (allowStatic && !modifiers.isEmpty
+        && optional('static', modifiers.head)) {
+      staticModifier = modifiers.head;
+      modifierCount++;
+      parseModifier(staticModifier);
+      modifiers = modifiers.tail;
+    }
+    if (modifiers.isEmpty) {
+      listener.handleModifiers(modifierCount);
+      return null;
+    }
+    if (modifiers.tail.isEmpty) {
+      Token modifier = modifiers.head;
+      if (isVarFinalOrConst(modifier)) {
+        modifierCount++;
+        parseModifier(modifier);
+        listener.handleModifiers(modifierCount);
+        return modifier;

[Johnni Winther, 2013/09/02 11:02:08]

Add a comment that the caller checks for 'var Type x'.

[ahe, 2013/09/02 17:49:59]

Done.

+      }
+    }
+
+    // Slow case to report errors.
+    List<Token> modifierList = modifiers.toList();
+    Token varFinalOrConst =
+        modifierList.firstWhere(isVarFinalOrConst, orElse: () => null);
+    if (allowStatic && staticModifier == null) {
+      staticModifier =
+          modifierList.firstWhere(
+              (modifier) => optional('static', modifier), orElse: () => null);
+      if (staticModifier != null) {
+        modifierCount++;
+        parseModifier(staticModifier);
+        modifierList.remove(staticModifier);
+      }
+    }
+    bool hasTypeOrModifier = hasType;
+    if (varFinalOrConst != null) {
+      parseModifier(varFinalOrConst);
+      modifierCount++;
+      hasTypeOrModifier = true;
+      modifierList.remove(varFinalOrConst);
+    }
+    listener.handleModifiers(modifierCount);
+    var kind = hasTypeOrModifier
+        ? MessageKind.EXTRANEOUS_MODIFIER
+        : MessageKind.EXTRANEOUS_MODIFIER_REPLACE;
+    for (Token modifier in modifierList) {
+      listener.reportError(modifier, kind, {'modifier': modifier});
+    }
+    return null;
+  }
+
+  Token parseFields(Token start,
+                    Link<Token> modifiers,
+                    Token type,
+                    Token getOrSet,
+                    Token name,
+                    bool isTopLevel) {
+    bool hasType = type != null;
+    Token varFinalOrConst =
+        expectVarFinalOrConst(modifiers, hasType, !isTopLevel);
+    bool isVar = false;
+    bool hasModifier = false;
+    if (varFinalOrConst != null) {
+      hasModifier = true;
+      isVar = optional('var', varFinalOrConst);
+    }
+
     if (getOrSet != null) {
-      // TODO(ahe): Enable this error:
-      // listener.recoverableError("unexpected", token: getOrSet);
+      var kind = (hasModifier || hasType)
+          ? MessageKind.EXTRANEOUS_MODIFIER
+          : MessageKind.EXTRANEOUS_MODIFIER_REPLACE;
+      listener.reportError(getOrSet, kind, {'modifier': getOrSet});
     }
-    parseModifierList(modifiers);
-    if (type == null) {
+
+    if (!hasType) {
       listener.handleNoType(name);
+    } else if (optional('void', type)) {
+      listener.handleNoType(name);
+      // TODO(ahe): This error is reported twice, second time is from
+      // [parseVariablesDeclarationMaybeSemicolon] via
+      // [PartialFieldListElement.parseNode].
+      listener.reportError(type, MessageKind.VOID_NOT_ALLOWED);
     } else {
-      // TODO(ahe): Report recoverable error on 'void'.
-      parseReturnTypeOpt(type);
+      parseType(type);
+      if (isVar) {
+        listener.reportError(
+            modifiers.head, MessageKind.EXTRANEOUS_MODIFIER,
+            {'modifier': modifiers.head});
+      }
     }
+
     Token token = parseIdentifier(name);
 
     int fieldCount = 1;
     token = parseVariableInitializerOpt(token);
     while (optional(',', token)) {
       token = parseIdentifier(token.next);
       token = parseVariableInitializerOpt(token);
       ++fieldCount;
     }
     expectSemicolon(token);
-    listener.endTopLevelFields(fieldCount, start, token);
+    if (isTopLevel) {
+      listener.endTopLevelFields(fieldCount, start, token);
+    } else {
+      listener.endFields(fieldCount, start, token);
+    }
     return token.next;
   }
 
   Token parseTopLevelMethod(Token start,
                             Link<Token> modifiers,
                             Token type,
                             Token getOrSet,
                             Token name) {
-    parseModifierList(modifiers);
+    Token externalModifier;
+    for (Token modifier in modifiers) {
+      if (externalModifier == null && optional('external', modifier)) {
+        externalModifier = modifier;
+      } else {
+        listener.reportError(
+            modifier, MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+      }
+    }
+    if (externalModifier != null) {
+      parseModifier(externalModifier);
+      listener.handleModifiers(1);
+    } else {
+      listener.handleModifiers(0);
+    }
+
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token = parseIdentifier(name);
 
     token = parseFormalParametersOpt(token);
-    token = parseFunctionBody(token, false);
+    token = parseFunctionBody(token, false, externalModifier != null);
     listener.endTopLevelMethod(start, getOrSet, token);
     return token.next;
   }
 
   Link<Token> findMemberName(Token token) {
     Token start = token;
     Link<Token> identifiers = const Link<Token>();
     while (!identical(token.kind, EOF_TOKEN)) {
       String value = token.stringValue;
       if ((identical(value, '(')) || (identical(value, '{'))
@@ skipping 248 matching lines @@
         if (identical(token.kind, EOF_TOKEN)) {
           // TODO(ahe): This is a hack, see parseTopLevelMember.
           listener.endFields(1, start, token);
           return token;
         }
       }
     }
 
     var modifiers = identifiers.reverse();
     return isField
-        ? parseFields(start, modifiers, type, getOrSet, name)
+        ? parseFields(start, modifiers, type, getOrSet, name, false)
         : parseMethod(start, modifiers, type, getOrSet, name);
 
   }
 
-  Token parseFields(Token start,
-                    Link<Token> modifiers,
-                    Token type,
-                    Token getOrSet,
-                    Token name) {
-    parseModifierList(modifiers);
-    if (type == null) {
-      listener.handleNoType(name);
-    } else {
-      parseReturnTypeOpt(type);
-    }
-
-    Token token = parseIdentifier(name);
-
-    int fieldCount = 1;
-    token = parseVariableInitializerOpt(token);
-    if (getOrSet != null) {
-      listener.recoverableError("unexpected", token: getOrSet);
-    }
-    while (optional(',', token)) {
-      // TODO(ahe): Count these.
-      token = parseIdentifier(token.next);
-      token = parseVariableInitializerOpt(token);
-      ++fieldCount;
-    }
-    expectSemicolon(token);
-    listener.endFields(fieldCount, start, token);
-    return token.next;
-  }
-
   Token parseMethod(Token start,
                     Link<Token> modifiers,
                     Token type,
                     Token getOrSet,
                     Token name) {
+    Token externalModifier;
+    Token staticModifier;
+    Token constModifier;
+    int modifierCount = 0;
+    int allowedModifierCount = 1;
+    for (Token modifier in modifiers) {
+      if (externalModifier == null && optional('external', modifier)) {
+        modifierCount++;
+        externalModifier = modifier;
+        if (modifierCount != allowedModifierCount) {
+          listener.reportError(
+              modifier,
+              MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+        }
+        allowedModifierCount++;
+      } else if (staticModifier == null && optional('static', modifier)) {
+        modifierCount++;
+        staticModifier = modifier;
+        if (modifierCount != allowedModifierCount) {
+          listener.reportError(
+              modifier,
+              MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+        }
+      } else if (constModifier == null && optional('const', modifier)) {
+        modifierCount++;
+        constModifier = modifier;
+        if (modifierCount != allowedModifierCount) {
+          listener.reportError(
+              modifier,
+              MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+        }
+      } else {
+        listener.reportError(
+            modifier, MessageKind.EXTRANEOUS_MODIFIER, {'modifier': modifier});
+      }
+    }
     parseModifierList(modifiers);
+
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token;
     if (optional('operator', name)) {
       token = parseOperatorName(name);
+      if (staticModifier != null) {
+        // TODO(ahe): Consider a more specific error message.
+        listener.reportError(
+            staticModifier, MessageKind.EXTRANEOUS_MODIFIER,
+            {'modifier': staticModifier});
+      }
     } else {
       token = parseIdentifier(name);
     }
 
     token = parseQualifiedRestOpt(token);
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
-      token = parseFunctionBody(token, false);
+      token = parseFunctionBody(
+          token, false, staticModifier == null || externalModifier != null);
     }
     listener.endMethod(getOrSet, start, token);
     return token.next;
   }
 
   Token parseFactoryMethod(Token token) {
     assert(isFactoryDeclaration(token));
     Token start = token;
-    if (identical(token.stringValue, 'external')) token = token.next;
+    Token externalModifier;
+    if (identical(token.stringValue, 'external')) {
+      externalModifier = token;
+      token = token.next;
+    }
     Token constKeyword = null;
     if (optional('const', token)) {
       constKeyword = token;
       token = token.next;
     }
     Token factoryKeyword = token;
     listener.beginFactoryMethod(factoryKeyword);
     token = token.next; // Skip 'factory'.
     token = parseConstructorReference(token);
     token = parseFormalParameters(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
-      token = parseFunctionBody(token, false);
+      token = parseFunctionBody(token, false, externalModifier != null);
     }
     listener.endFactoryMethod(start, token);
     return token.next;
   }
 
   Token parseOperatorName(Token token) {
     assert(optional('operator', token));
     if (isUserDefinableOperator(token.next.stringValue)) {
       Token operator = token;
       token = token.next;
@@ skipping 22 matching lines @@
         token = parseIdentifier(token);
       }
     }
     token = parseQualifiedRestOpt(token);
     listener.endFunctionName(token);
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
-      token = parseFunctionBody(token, false);
+      token = parseFunctionBody(token, false, true);
     }
     listener.endFunction(getOrSet, token);
     return token.next;
   }
 
   Token parseUnamedFunction(Token token) {
     listener.beginUnamedFunction(token);
     token = parseFormalParameters(token);
     bool isBlock = optional('{', token);
-    token = parseFunctionBody(token, true);
+    token = parseFunctionBody(token, true, false);
     listener.endUnamedFunction(token);
     return isBlock ? token.next : token;
   }
 
   Token parseFunctionDeclaration(Token token) {
     listener.beginFunctionDeclaration(token);
     token = parseFunction(token, null);
     listener.endFunctionDeclaration(token);
     return token;
   }
 
   Token parseFunctionExpression(Token token) {
     listener.beginFunction(token);
     listener.handleModifiers(0);
     token = parseReturnTypeOpt(token);
     listener.beginFunctionName(token);
     token = parseIdentifier(token);
     listener.endFunctionName(token);
     token = parseFormalParameters(token);
     listener.handleNoInitializers();
     bool isBlock = optional('{', token);
-    token = parseFunctionBody(token, true);
+    token = parseFunctionBody(token, true, false);
     listener.endFunction(null, token);
     return isBlock ? token.next : token;
   }
 
   Token parseConstructorReference(Token token) {
     Token start = token;
     listener.beginConstructorReference(start);
     token = parseIdentifier(token);
     token = parseQualifiedRestOpt(token);
     token = parseTypeArgumentsOpt(token);
@@ skipping 10 matching lines @@
     listener.beginRedirectingFactoryBody(token);
     assert(optional('=', token));
     Token equals = token;
     token = parseConstructorReference(token.next);
     Token semicolon = token;
     expectSemicolon(token);
     listener.endRedirectingFactoryBody(equals, semicolon);
     return token;
   }
 
-  Token parseFunctionBody(Token token, bool isExpression) {
+  Token parseFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     if (optional(';', token)) {
+      if (!allowAbstract) {
+        listener.reportError(token, MessageKind.BODY_EXPECTED);
+      }
       listener.endFunctionBody(0, null, token);
       return token;
     } else if (optional('=>', token)) {
       Token begin = token;
       token = parseExpression(token.next);
       if (!isExpression) {
         expectSemicolon(token);
         listener.endReturnStatement(true, begin, token);
       } else {
         listener.endReturnStatement(true, begin, null);
@@ skipping 711 matching lines @@
       listener.unexpected(token);
     }
     return token;
   }
 
   Token parseVariablesDeclaration(Token token) {
     return parseVariablesDeclarationMaybeSemicolon(token, true);
   }
 
   Token parseVariablesDeclarationNoSemicolon(Token token) {
+    // Only called when parsing a for loop, so this is for parsing locals.
     return parseVariablesDeclarationMaybeSemicolon(token, false);
   }
 
   Token parseVariablesDeclarationMaybeSemicolon(Token token,
                                                 bool endWithSemicolon) {
     int count = 1;
     listener.beginVariablesDeclaration(token);
     token = parseModifiers(token);
     token = parseTypeOpt(token);
     token = parseOptionallyInitializedIdentifier(token);
@@ skipping 330 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }