Revert "Add support for the new function-type syntax."

pkg/compiler/lib/src/parser/node_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.node_listener;
 
 import '../common.dart';
 import '../elements/elements.dart' show CompilationUnitElement;
 import 'package:front_end/src/fasta/scanner/precedence.dart' as Precedence
     show INDEX_INFO;
@@ skipping 108 matching lines @@
     pushNode(node);
     super.endTopLevelDeclaration(token);
   }
 
   @override
   void endCompilationUnit(int count, Token token) {
     pushNode(makeNodeList(count, null, null, '\n'));
   }
 
   @override
-  void endFunctionTypeAlias(
-      Token typedefKeyword, Token equals, Token endToken) {
-    bool isGeneralizedTypeAlias;
-    NodeList templateParameters;
-    TypeAnnotation returnType;
-    Identifier name;
-    NodeList typeParameters;
-    NodeList formals;
-    if (equals == null) {
-      isGeneralizedTypeAlias = false;
-      formals = popNode();
-      templateParameters = popNode();
-      name = popNode();
-      returnType = popNode();
-    } else {
-      // TODO(floitsch): keep using the `FunctionTypeAnnotation' node.
-      isGeneralizedTypeAlias = true;
-      Node type = popNode();
-      if (type.asFunctionTypeAnnotation() == null) {
-        // TODO(floitsch): The parser should diagnose this problem, not
-        // this listener.
-        // However, this problem goes away, when we allow aliases for
-        // non-function types too.
-        reportFatalError(type, 'Expected a function type.');
-      }
-      FunctionTypeAnnotation functionType = type;
-      templateParameters = popNode();
-      name = popNode();
-      returnType = functionType.returnType;
-      typeParameters = functionType.typeParameters;
-      formals = functionType.formals;
-    }
+  void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
+    NodeList formals = popNode();
+    NodeList typeParameters = popNode();
+    Identifier name = popNode();
+    TypeAnnotation returnType = popNode();
     pushNode(new Typedef(
-        isGeneralizedTypeAlias,
-        templateParameters,
-        returnType,
-        name,
-        typeParameters,
-        formals,
-        typedefKeyword,
-        endToken));
-  }
-
-  void handleNoName(Token token) {
-    pushNode(null);
+        returnType, name, typeParameters, formals, typedefKeyword, endToken));
   }
 
   @override
-  void handleFunctionType(Token functionToken, Token endToken) {
-    NodeList formals = popNode();
-    NodeList typeParameters = popNode();
-    TypeAnnotation returnType = popNode();
-    pushNode(new FunctionTypeAnnotation(
-        returnType, functionToken, typeParameters, formals));
-  }
-
-  @override
   void endNamedMixinApplication(
       Token beginToken, Token classKeyword, Token equals,
       Token implementsKeyword, Token endToken) {
     NodeList interfaces = (implementsKeyword != null) ? popNode() : null;
     Node mixinApplication = popNode();
     NodeList typeParameters = popNode();
     Identifier name = popNode();
     Modifiers modifiers = popNode();
     pushNode(new NamedMixinApplication(name, typeParameters, modifiers,
         mixinApplication, interfaces, beginToken, endToken));
@@ skipping 73 matching lines @@
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
     Identifier name = null;
     if (periodBeforeName != null) {
       name = popNode();
     }
     NodeList typeArguments = popNode();
     Node classReference = popNode();
     if (typeArguments != null) {
-      classReference = new NominalTypeAnnotation(classReference, typeArguments);
+      classReference = new TypeAnnotation(classReference, typeArguments);
     } else {
       Identifier identifier = classReference.asIdentifier();
       Send send = classReference.asSend();
       if (identifier != null) {
         // TODO(ahe): Should be:
         // classReference = new Send(null, identifier);
         classReference = identifier;
       } else if (send != null) {
         classReference = send;
       } else {
@@ skipping 617 matching lines @@
     NodeList arguments = popNode();
     if (arguments == null) {
       // This is a constant expression.
       Identifier name;
       if (periodBeforeName != null) {
         name = popNode();
       }
       NodeList typeArguments = popNode();
       Node receiver = popNode();
       if (typeArguments != null) {
-        receiver = new NominalTypeAnnotation(receiver, typeArguments);
+        receiver = new TypeAnnotation(receiver, typeArguments);
         recoverableError(typeArguments, 'Type arguments are not allowed here.');
       } else {
         Identifier identifier = receiver.asIdentifier();
         Send send = receiver.asSend();
         if (identifier != null) {
           receiver = new Send(null, identifier);
         } else if (send == null) {
           internalError(node: receiver);
         }
       }
@@ skipping 73 matching lines @@
     }
     lastErrorWasNativeFunctionBody = false;
   }
 
   void internalError({Token token, Node node}) {
     // TODO(ahe): This should call reporter.internalError.
     Spannable spannable = (token == null) ? node : token;
     throw new SpannableAssertionFailure(spannable, 'Internal error in parser.');
   }
 }