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

pkg/compiler/lib/src/resolution/class_hierarchy.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.resolution.class_hierarchy;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../core_types.dart' show CommonElements;
 import '../elements/resolution_types.dart';
@@ skipping 48 matching lines @@
       if (nameSet.contains(typeName)) {
         reporter.reportErrorMessage(
             typeNode,
             MessageKind.DUPLICATE_TYPE_VARIABLE_NAME,
             {'typeVariableName': typeName});
       }
       nameSet.add(typeName);
 
       TypeVariableElementX variableElement = typeVariable.element;
       if (typeNode.bound != null) {
-        ResolutionDartType boundType = typeResolver
-            .resolveNominalTypeAnnotation(this, typeNode.bound, const []);
+        ResolutionDartType boundType =
+            typeResolver.resolveTypeAnnotation(this, typeNode.bound);
         variableElement.boundCache = boundType;
 
         void checkTypeVariableBound() {
           Link<TypeVariableElement> seenTypeVariables =
               const Link<TypeVariableElement>();
           seenTypeVariables = seenTypeVariables.prepend(variableElement);
           ResolutionDartType bound = boundType;
           while (bound.isTypeVariable) {
             TypeVariableElement element = bound.element;
             if (seenTypeVariables.contains(element)) {
@@ skipping 162 matching lines @@
     }
 
     EnumCreator creator =
         new EnumCreator(reporter, resolution.commonElements, element);
     creator.createMembers();
     return enumType;
   }
 
   /// Resolves the mixed type for [mixinNode] and checks that the mixin type
   /// is a valid, non-blacklisted interface type. The mixin type is returned.
-  ResolutionDartType checkMixinType(NominalTypeAnnotation mixinNode) {
-    ResolutionDartType mixinType = resolveNominalType(mixinNode);
+  ResolutionDartType checkMixinType(TypeAnnotation mixinNode) {
+    ResolutionDartType mixinType = resolveType(mixinNode);
     if (isBlackListed(mixinType)) {
       reporter.reportErrorMessage(
           mixinNode, MessageKind.CANNOT_MIXIN, {'type': mixinType});
     } else if (mixinType.isTypeVariable) {
       reporter.reportErrorMessage(mixinNode, MessageKind.CLASS_NAME_EXPECTED);
     } else if (mixinType.isMalformed) {
       reporter.reportErrorMessage(mixinNode, MessageKind.CANNOT_MIXIN_MALFORMED,
           {'className': element.name, 'malformedType': mixinType});
     } else if (mixinType.isEnumType) {
       reporter.reportErrorMessage(mixinNode, MessageKind.CANNOT_MIXIN_ENUM,
@@ skipping 168 matching lines @@
         // the mixin for this application to avoid getting into
         // infinite recursion when traversing members.
         return null;
       }
       previous = current;
       current = currentMixinApplication.mixin;
     }
     return mixinType;
   }
 
-  ResolutionDartType resolveNominalType(NominalTypeAnnotation node) {
-    return typeResolver.resolveNominalTypeAnnotation(this, node, const []);
+  ResolutionDartType resolveType(TypeAnnotation node) {
+    return typeResolver.resolveTypeAnnotation(this, node);
   }
 
   ResolutionDartType resolveSupertype(
-      ClassElement cls, NominalTypeAnnotation superclass) {
-    ResolutionDartType supertype = resolveNominalType(superclass);
+      ClassElement cls, TypeAnnotation superclass) {
+    ResolutionDartType supertype = resolveType(superclass);
     if (supertype != null) {
       if (supertype.isMalformed) {
         reporter.reportErrorMessage(
             superclass,
             MessageKind.CANNOT_EXTEND_MALFORMED,
             {'className': element.name, 'malformedType': supertype});
         return objectType;
       } else if (supertype.isEnumType) {
         reporter.reportErrorMessage(superclass, MessageKind.CANNOT_EXTEND_ENUM,
             {'className': element.name, 'enumType': supertype});
         return objectType;
       } else if (!supertype.isInterfaceType) {
         reporter.reportErrorMessage(
             superclass.typeName, MessageKind.CLASS_NAME_EXPECTED);
         return objectType;
       } else if (isBlackListed(supertype)) {
         reporter.reportErrorMessage(
             superclass, MessageKind.CANNOT_EXTEND, {'type': supertype});
         return objectType;
       }
     }
     return supertype;
   }
 
   Link<ResolutionDartType> resolveInterfaces(
       NodeList interfaces, Node superclass) {
     Link<ResolutionDartType> result = const Link<ResolutionDartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
-      ResolutionDartType interfaceType = resolveNominalType(link.head);
+      ResolutionDartType interfaceType = resolveType(link.head);
       if (interfaceType != null) {
         if (interfaceType.isMalformed) {
           reporter.reportErrorMessage(
               link.head,
               MessageKind.CANNOT_IMPLEMENT_MALFORMED,
               {'className': element.name, 'malformedType': interfaceType});
         } else if (interfaceType.isEnumType) {
           reporter.reportErrorMessage(
               link.head,
               MessageKind.CANNOT_IMPLEMENT_ENUM,
               {'className': element.name, 'enumType': interfaceType});
         } else if (!interfaceType.isInterfaceType) {
           // TODO(johnniwinther): Handle dynamic.
-          NominalTypeAnnotation typeAnnotation = link.head;
+          TypeAnnotation typeAnnotation = link.head;
           reporter.reportErrorMessage(
               typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
         } else {
           if (interfaceType == element.supertype) {
             reporter.reportErrorMessage(
                 superclass,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
             reporter.reportErrorMessage(
                 link.head,
@@ skipping 104 matching lines @@
     node.superclass.accept(this);
     visitNodeList(node.mixins);
   }
 
   void visitNamedMixinApplication(NamedMixinApplication node) {
     node.superclass.accept(this);
     visitNodeList(node.mixins);
     visitNodeList(node.interfaces);
   }
 
-  void visitNominalTypeAnnotation(NominalTypeAnnotation node) {
+  void visitTypeAnnotation(TypeAnnotation node) {
     node.typeName.accept(this);
   }
 
   void visitIdentifier(Identifier node) {
     Element element = lookupInScope(reporter, node, context, node.source);
     if (element != null && element.isClass) {
       loadSupertype(element, node);
     }
   }
 
@@ skipping 14 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType) {
       reporter.reportErrorMessage(node.selector,
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }