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>();
+
+    // `true` if 'get' has been seen.
+    bool isGetter = false;
+    // `true` if an identifier has been seen after 'get'.
+    bool hasName = false;
+    // `true` if 'sync' or 'async' has been seen after a name.
+    bool hasAsync = false;

[floitsch, 2015/01/30 10:48:13]

So far this seems unused.

[Johnni Winther, 2015/01/30 12:16:33]

Removed.

+
     while (!identical(token.kind, EOF_TOKEN)) {
       String value = token.stringValue;
-      if ((identical(value, '(')) || (identical(value, '{'))
-          || (identical(value, '=>'))) {
+      if (identical(value, 'get')) {

[floitsch, 2015/01/30 10:48:13]

Why is this "identical"?

(it was already there before, but it feels unnecessary and error-prone)

[Johnni Winther, 2015/01/30 12:16:33]

The pattern is from when identical on String was faster than ==. I guess that is
no longer the case.

Replaced all uses in this method.

[floitsch, 2015/01/30 12:18:14]

It might still be, but it feels error-prone to depend on the fact that the token
uses the literal "get" and not anything else.

[Johnni Winther, 2015/01/30 15:40:16]

According to http://dartbug.com/15514 the problem is resolved.

+        isGetter = true;
+      } else if (hasName &&
+                 (identical(value, 'sync') || identical(value, 'async'))) {
+        // Skip.
+        token = token.next;

[floitsch, 2015/01/30 10:48:13]

shouldn't you set the 'hasAsync' to true?

[Johnni Winther, 2015/01/30 12:16:33]

Wasn't needed after all.

+        value = token.stringValue;
+        if (identical(value, '*')) {
+          // Skip.
+          token = token.next;
+        }
+        continue;
+      } else if (identical(value, '(') ||
+                 identical(value, '{') ||
+                 identical(value, '=>')) {
         // A method.
+        identifiers = identifiers.prepend(token);
         return identifiers;
-      } else if ((identical(value, '=')) || (identical(value, ';'))
-          || (identical(value, ','))) {
+      } else if (identical(value, '=') ||
+                 identical(value, ';') ||
+                 identical(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);
   }
 }