Add support for the new function-type syntax.

pkg/compiler/lib/src/parser/element_listener.dart

 // Copyright (c) 2015, 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.element_listener;
 
 import '../common.dart';
 import '../diagnostics/messages.dart' show MessageTemplate;
 import '../elements/elements.dart'
     show Element, LibraryElement, MetadataAnnotation;
@@ skipping 271 matching lines @@
   void rejectBuiltInIdentifier(Identifier name) {
     if (name.token is KeywordToken) {
       Keyword keyword = (name.token as KeywordToken).keyword;
       if (!keyword.isPseudo) {
         recoverableError(name, "Illegal name '${keyword.syntax}'.");
       }
     }
   }
 
   @override
-  void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
-    popNode(); // TODO(karlklose): do not throw away typeVariables.
-    Identifier name = popNode();
-    popNode(); // returnType
+  void endFunctionTypeAlias(
+      Token typedefKeyword, Token equals, Token endToken) {
+    Identifier name;
+    if (equals == null) {
+      popNode(); // TODO(karlklose): do not throw away typeVariables.
+      name = popNode();
+      popNode(); // returnType
+    } else {
+      popNode();  // Function type.
+      popNode();  // TODO(karlklose): do not throw away typeVariables.
+      name = popNode();
+    }
     pushElement(new PartialTypedefElement(
         name.source, compilationUnitElement, typedefKeyword, endToken));
     rejectBuiltInIdentifier(name);
   }
 
   @override
   void endNamedMixinApplication(
       Token beginToken, Token classKeyword, Token equals,
       Token implementsKeyword, Token endToken) {
     NodeList interfaces = (implementsKeyword != null) ? popNode() : null;
@@ skipping 13 matching lines @@
     int id = idGenerator.getNextFreeId();
     Element enclosing = compilationUnitElement;
     pushElement(new NamedMixinApplicationElementX(
         name.source, enclosing, id, namedMixinApplication));
     rejectBuiltInIdentifier(name);
   }
 
   @override
   void endMixinApplication() {
     NodeList mixins = popNode();
-    TypeAnnotation superclass = popNode();
+    NominalTypeAnnotation superclass = popNode();
     pushNode(new MixinApplication(superclass, mixins));
   }
 
   @override
   void handleVoidKeyword(Token token) {
-    pushNode(new TypeAnnotation(new Identifier(token), null));
+    pushNode(new NominalTypeAnnotation(new Identifier(token), null));
   }
 
   @override
   void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
     bool hasParseError = currentMemberHasParseError;
     memberErrors = memberErrors.tail;
     popNode(); // typeVariables
     Identifier name = popNode();
     popNode(); // type
     Modifiers modifiers = popNode();
@@ skipping 52 matching lines @@
     pushNode(new Send(first, last));
   }
 
   @override
   void handleNoType(Token token) {
     pushNode(null);
   }
 
   @override
   void endTypeVariable(Token token, Token extendsOrSuper) {
-    TypeAnnotation bound = popNode();
+    NominalTypeAnnotation bound = popNode();
     Identifier name = popNode();
     pushNode(new TypeVariable(name, extendsOrSuper, bound));
     rejectBuiltInIdentifier(name);
   }
 
   @override
   void endTypeVariables(int count, Token beginToken, Token endToken) {
     pushNode(makeNodeList(count, beginToken, endToken, ','));
   }
 
   @override
   void handleNoTypeVariables(Token token) {
     pushNode(null);
   }
 
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
     pushNode(makeNodeList(count, beginToken, endToken, ','));
   }
 
   @override
   void handleNoTypeArguments(Token token) {
     pushNode(null);
   }
 
   @override
-  void endType(Token beginToken, Token endToken) {
+  void handleType(Token beginToken, Token endToken) {
     NodeList typeArguments = popNode();
     Expression typeName = popNode();
-    pushNode(new TypeAnnotation(typeName, typeArguments));
+    pushNode(new NominalTypeAnnotation(typeName, typeArguments));
+  }
+
+  void handleNoName(Token token) {
+    pushNode(null);
   }
 
   @override
+  void handleFunctionType(Token functionToken, Token endToken) {
+    popNode();  // Type parameters.
+    popNode();  // Return type.
+    pushNode(null);
+  }
+
+  @override
   void handleParenthesizedExpression(BeginGroupToken token) {
     Expression expression = popNode();
     pushNode(new ParenthesizedExpression(expression, token));
   }
 
   @override
   void handleModifier(Token token) {
     pushNode(new Identifier(token));
   }
 
@@ skipping 175 matching lines @@
         errorCode = MessageKind.INVALID_AWAIT_FOR;
         break;
 
       case ErrorKind.AsciiControlCharacter:
       case ErrorKind.NonAsciiIdentifier:
       case ErrorKind.NonAsciiWhitespace:
       case ErrorKind.Encoding:
         errorCode = MessageKind.BAD_INPUT_CHARACTER;
         break;
 
+      case ErrorKind.InvalidInlineFunctionType:
+        errorCode = MessageKind.INVALID_INLINE_FUNCTION_TYPE;
+        break;
+
       case ErrorKind.InvalidSyncModifier:
         errorCode = MessageKind.INVALID_SYNC_MODIFIER;
         break;
 
       case ErrorKind.InvalidVoid:
         errorCode = MessageKind.VOID_NOT_ALLOWED;
         break;
 
       case ErrorKind.UnexpectedDollarInString:
         errorCode = MessageKind.MALFORMED_STRING_LITERAL;
@@ skipping 267 matching lines @@
       memberErrors = memberErrors.tail.prepend(true);
     }
     reporter.reportErrorMessage(spannable, errorCode, arguments);
   }
 
   void reportErrorFromToken(Token token, MessageKind errorCode,
       [Map arguments = const {}]) {
     reportError(reporter.spanFromToken(token), errorCode, arguments);
   }
 }