Support async getters.

pkg/compiler/lib/src/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;
 
 class FormalParameterType {
   final String type;
   const FormalParameterType(this.type);
   bool get isRequired => this == REQUIRED;
@@ skipping 666 matching lines @@
   }
 
   Token parseTopLevelMember(Token token) {
     Token start = token;
     listener.beginTopLevelMember(token);
 
     Link<Token> identifiers = findMemberName(token);
     if (identifiers.isEmpty) {
       return listener.expectedDeclaration(start);
     }
+    Token afterName = identifiers.head;
+    identifiers = identifiers.tail;
+
+    if (identifiers.isEmpty) {
+      return listener.expectedDeclaration(start);
+    }
     Token name = identifiers.head;
     identifiers = identifiers.tail;
     Token getOrSet;
     if (!identifiers.isEmpty) {
       String value = identifiers.head.stringValue;
       if ((identical(value, 'get')) || (identical(value, 'set'))) {
         getOrSet = identifiers.head;
         identifiers = identifiers.tail;
       }
     }
     Token type;
     if (!identifiers.isEmpty) {
       if (isValidTypeReference(identifiers.head)) {
         type = identifiers.head;
         identifiers = identifiers.tail;
       }
     }
 
-    token = name.next;
+    token = afterName;
     bool isField;
     while (true) {
       // Loop to allow the listener to rewrite the token stream for
       // error handling.
       final String value = token.stringValue;
       if ((identical(value, '(')) || (identical(value, '{'))
           || (identical(value, '=>'))) {
         isField = false;
         break;
       } else if ((identical(value, '=')) || (identical(value, ','))) {
@@ skipping 143 matching lines @@
       listener.endFields(fieldCount, start, semicolon);
     }
     return token;
   }
 
   Token parseTopLevelMethod(Token start,
                             Link<Token> modifiers,
                             Token type,
                             Token getOrSet,
                             Token name) {
+
     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) {
@@ skipping 19 matching lines @@
     awaitIsKeyword = previousAwaitIsKeyword;
     Token endToken = token;
     token = token.next;
     if (token.kind == BAD_INPUT_TOKEN) {
       token = listener.unexpected(token);
     }
     listener.endTopLevelMethod(start, getOrSet, endToken);
     return token;
   }
 
+  /// Looks ahead to find the name of a member. Returns a link of the modifiers,
+  /// set/get, (operator) name, and either the start of the method body or the
+  /// end of the declaration.
+  ///
+  /// Examples:
+  ///
+  ///     int get foo;
+  /// results in
+  ///     [';', 'foo', 'get', 'int']
+  ///
+  ///
+  ///     static const List<int> foo = null;
+  /// results in
+  ///     ['=', 'foo', 'List', 'const', 'static']
+  ///
+  ///
+  ///     get foo async* { return null }
+  /// results in
+  ///     ['{', 'foo', 'get']
+  ///
+  ///
+  ///     operator *(arg) => null;
+  /// results in
+  ///     ['(', '*', 'operator']
+  ///
   Link<Token> findMemberName(Token token) {
     Token start = token;
     Link<Token> identifiers = const Link<Token>();
-    while (!identical(token.kind, EOF_TOKEN)) {
+
+    // `true` if 'get' has been seen.
+    bool isGetter = false;
+    // `true` if an identifier has been seen after 'get'.
+    bool hasName = false;
+
+    while (token.kind != EOF_TOKEN) {
       String value = token.stringValue;
-      if ((identical(value, '(')) || (identical(value, '{'))
-          || (identical(value, '=>'))) {
+      if (value == 'get') {
+        isGetter = true;
+      } else if (hasName &&
+                 (value == 'sync' || value == 'async')) {

[ahe, 2016/04/25 12:54:15]

FWIW, for sake of performance, it's important that you use identical when
comparing keywords in the parser.

[Johnni Winther, 2016/04/25 13:36:02]

I was under the imprecision that the VM had optimized for this.

[ahe, 2016/04/25 13:39:53]

It's probably optimized with something like this:

operator ==(String s) {
  if (identical(this, s)) return true;
  // Normal "slow" case.
}

So we often end up in the slow case.

+        // Skip.
+        token = token.next;
+        value = token.stringValue;
+        if (value == '*') {
+          // Skip.
+          token = token.next;
+        }
+        continue;
+      } else if (value == '(' ||
+                 value == '{' ||
+                 value == '=>') {
         // A method.
+        identifiers = identifiers.prepend(token);
         return identifiers;
-      } else if ((identical(value, '=')) || (identical(value, ';'))
-          || (identical(value, ','))) {
+      } else if (value == '=' ||
+                 value == ';' ||
+                 value == ',') {
         // A field or abstract getter.
+        identifiers = identifiers.prepend(token);
         return identifiers;
+      } else if (isGetter) {
+        hasName = true;
       }
       identifiers = identifiers.prepend(token);
       if (isValidTypeReference(token)) {
         // type ...
         if (optional('.', token.next)) {
           // type '.' ...
           if (token.next.next.isIdentifier()) {
             // type '.' identifier
             token = token.next.next;
           }
@@ skipping 176 matching lines @@
     if (isFactoryDeclaration(token)) {
       return parseFactoryMethod(token);
     }
     Token start = token;
     listener.beginMember(token);
 
     Link<Token> identifiers = findMemberName(token);
     if (identifiers.isEmpty) {
       return listener.expectedDeclaration(start);
     }
+    Token afterName = identifiers.head;
+    identifiers = identifiers.tail;
+
+    if (identifiers.isEmpty) {
+      return listener.expectedDeclaration(start);
+    }
     Token name = identifiers.head;
-    Token afterName = name.next;
     identifiers = identifiers.tail;
     if (!identifiers.isEmpty) {
       if (optional('operator', identifiers.head)) {
         name = identifiers.head;
         identifiers = identifiers.tail;
       }
     }
     Token getOrSet;
     if (!identifiers.isEmpty) {
       if (isGetOrSet(identifiers.head)) {
@@ skipping 166 matching lines @@
       listener.handleOperatorName(operator, token);
       return token.next;
     } else {
       return parseIdentifier(token);
     }
   }
 
   Token parseFunction(Token token, Token getOrSet) {
     listener.beginFunction(token);
     token = parseModifiers(token);
-    if (identical(getOrSet, token)) token = token.next;
-    if (optional('operator', token)) {
+    if (identical(getOrSet, token)) {
+      // get <name>  => ...
+      token = token.next;
+      listener.handleNoType(token);
+      listener.beginFunctionName(token);
+      if (optional('operator', token)) {
+        token = parseOperatorName(token);
+      } else {
+        token = parseIdentifier(token);
+      }
+    } else if (optional('operator', token)) {
+      // operator <op> (...
       listener.handleNoType(token);
       listener.beginFunctionName(token);
       token = parseOperatorName(token);
     } else {
+      // <type>? <get>? <name>
       token = parseReturnTypeOpt(token);
-      if (identical(getOrSet, token)) token = token.next;
+      if (identical(getOrSet, token)) {
+        token = token.next;
+      }
       listener.beginFunctionName(token);
       if (optional('operator', token)) {
         token = parseOperatorName(token);
       } else {
         token = parseIdentifier(token);
       }
     }
     token = parseQualifiedRestOpt(token);
     listener.endFunctionName(token);
     token = parseFormalParametersOpt(token);
@@ skipping 1275 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }