Add support for the new function-type syntax.

pkg/compiler/lib/src/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 dart2js.parser;
 
 import '../common.dart';
 import '../tokens/keyword.dart' show Keyword;
 import '../tokens/precedence.dart' show PrecedenceInfo;
 import '../tokens/precedence_constants.dart'
@@ skipping 344 matching lines @@
       period = token;
       token = parseIdentifier(token.next);
     }
     token = parseArgumentsOpt(token);
     listener.endMetadata(atToken, period, token);
     return token;
   }
 
   Token parseTypedef(Token token) {
     Token typedefKeyword = token;
-    listener.beginFunctionTypeAlias(token);
-    token = parseReturnTypeOpt(token.next);
-    token = parseIdentifier(token);
-    token = parseTypeVariablesOpt(token);
-    token = parseFormalParameters(token);
-    listener.endFunctionTypeAlias(typedefKeyword, token);
+    if (optional('=', peekAfterType(token.next))) {
+      listener.beginNewFunctionTypeAlias(token);
+      token = parseIdentifier(token.next);
+      token = parseTypeVariablesOpt(token);
+      token = expect('=', token);
+      token = parseFunctionType(token);
+      listener.endNewFunctionTypeAlias(typedefKeyword, token);
+    } else {
+      listener.beginFunctionTypeAlias(token);
+      token = parseReturnTypeOpt(token.next);
+      token = parseIdentifier(token);
+      token = parseTypeVariablesOpt(token);
+      token = parseFormalParameters(token);
+      listener.endFunctionTypeAlias(typedefKeyword, token);

[Siggi Cherem (dart-lang), 2016/12/12 23:20:40]

a suggestion to make this match closer to what the parser does in a few other
places:
 - keep a single begin/end for FunctionTypeAlias
 - add an argument to the `endFunctionTypeAlias` (and maybe to the begin as
well) that passes in the '=' token.

Listeners can then make the code behave differently depending on that.


(We do this in a bunch of places, see for example `endForIn` how it decides what
to do depending on the presence of the `await` token).

[floitsch, 2016/12/29 19:57:46]

Done.

+    }
     return expect(';', token);
   }
 
   Token parseMixinApplication(Token token) {
     listener.beginMixinApplication(token);
     token = parseType(token);
     token = expect('with', token);
     token = parseTypeList(token);
     listener.endMixinApplication();
     return token;
@@ skipping 425 matching lines @@
       token = parseIdentifier(token);
       token = parseQualifiedRestOpt(token);
     } else {
       token = listener.expectedType(token);
     }
     token = parseTypeArgumentsOpt(token);
     listener.endType(begin, token);
     return token;
   }
 
+  Token parseFunctionType(Token token) {
+    Token begin = token;
+    listener.beginFunctionType(token);
+    token = parseReturnTypeOpt(token);
+    // TODO(floitsch): don't use string comparison, but the keyword-state table
+    // is currently not set up to deal with upper-case characters.

[Siggi Cherem (dart-lang), 2016/12/12 23:20:40]

can this count as a reason to switch to `fun` or `function` or `<-`?

;-)

[floitsch, 2016/12/29 19:57:46]

nice try ;)

+    if (token.value != "Function") {
+      return listener.expected("Function", token);
+    }
+    token = token.next;
+    token = parseTypeVariablesOpt(token);
+    token = parseFormalParameters(token);
+    listener.endFunctionType(begin, token);
+    return token;
+  }
+
   Token parseTypeArgumentsOpt(Token token) {
     return parseStuff(
         token,
         (t) => listener.beginTypeArguments(t),
         (t) => parseType(t),
         (c, bt, et) => listener.endTypeArguments(c, bt, et),
         (t) => listener.handleNoTypeArguments(t));
   }
 
   Token parseTypeVariablesOpt(Token token) {
@@ skipping 2143 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }