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

pkg/compiler/lib/src/resolution/type_resolver.dart

Index: pkg/compiler/lib/src/resolution/type_resolver.dart
diff --git a/pkg/compiler/lib/src/resolution/type_resolver.dart b/pkg/compiler/lib/src/resolution/type_resolver.dart
index 34e5cab4dc2d1a45624868171b19b9f6f5bf6edb..318e7488f429e86e8c8693d209a82407658f3935 100644
--- a/pkg/compiler/lib/src/resolution/type_resolver.dart
+++ b/pkg/compiler/lib/src/resolution/type_resolver.dart
@@ -27,16 +27,6 @@ import 'registry.dart' show ResolutionRegistry;
 import 'resolution_common.dart' show MappingVisitor;
 import 'scope.dart' show Scope;
 
-class _FormalsTypeResolutionResult {
-  final List<ResolutionDartType> requiredTypes;
-  final List<ResolutionDartType> orderedTypes;
-  final List<String> names;
-  final List<ResolutionDartType> nameTypes;
-
-  _FormalsTypeResolutionResult(
-      this.requiredTypes, this.orderedTypes, this.names, this.nameTypes);
-}
-
 class TypeResolver {
   final Resolution resolution;
 
@@ -76,154 +66,6 @@ class TypeResolver {
   ResolutionDartType resolveTypeAnnotation(
       MappingVisitor visitor, TypeAnnotation node,
       {bool malformedIsError: false, bool deferredIsMalformed: true}) {
-    return _resolveTypeAnnotation(
-        visitor, node, const [], malformedIsError: malformedIsError,
-        deferredIsMalformed: deferredIsMalformed);
-  }
-
-  // TODO(floitsch): the [visibleTypeParameterNames] is a hack to put
-  // type parameters in scope for the nested types.
-  //
-  // For example, in the following example, the generic type "A" would be stored
-  // in `visibleTypeParameterNames`.
-  // `typedef F = Function(List<A> Function<A>(A x))`.
-  //
-  // They are resolved to `dynamic` until dart2js supports generic methods.
-  ResolutionDartType _resolveTypeAnnotation(
-      MappingVisitor visitor, TypeAnnotation node,
-      List<List<String>> visibleTypeParameterNames,
-      {bool malformedIsError: false, bool deferredIsMalformed: true}) {
-
-    if (node.asNominalTypeAnnotation() != null) {
-      return resolveNominalTypeAnnotation(
-          visitor, node,
-          visibleTypeParameterNames,
-          malformedIsError: malformedIsError,
-          deferredIsMalformed: deferredIsMalformed);
-    }
-    assert(node.asFunctionTypeAnnotation() != null);
-    return _resolveFunctionTypeAnnotation(
-        visitor, node, visibleTypeParameterNames,
-        malformedIsError: malformedIsError,
-        deferredIsMalformed: deferredIsMalformed);
-  }
-
-  /// Resolves the types of a parameter list.
-  ///
-  /// This function does not accept "inline" function types. For example
-  /// `foo(int bar(String x))` is not accepted.
-  ///
-  /// However, it does work with nested generalized function types:
-  ///   `foo(int Function(String) x)`.
-  _FormalsTypeResolutionResult _resolveFormalTypes(
-      MappingVisitor visitor, NodeList formals,
-      List<List<String>> visibleTypeParameterNames) {
-
-    ResolutionDartType resolvePositionalType(VariableDefinitions node) {
-      return _resolveTypeAnnotation(
-          visitor, node.type, visibleTypeParameterNames);
-    }
-
-    void fillNamedTypes(NodeList namedFormals,
-        List<String> names, List<ResolutionDartType> types) {
-      List<Node> nodes = namedFormals.nodes.toList(growable: false);
-
-      // Sort the named arguments first.
-      nodes.sort((node1, node2) {
-        VariableDefinitions a = node1;
-        VariableDefinitions b = node2;
-        assert(a.definitions.nodes.tail.isEmpty);
-        assert(b.definitions.nodes.tail.isEmpty);
-        return a.definitions.nodes.head.asIdentifier().source.compareTo(
-            b.definitions.nodes.head.asIdentifier().source);
-      });
-
-      for (VariableDefinitions node in nodes) {
-        String name = node.definitions.nodes.head.asIdentifier().source;
-        ResolutionDartType type = node.type == null
-            ? const ResolutionDynamicType()
-            : _resolveTypeAnnotation(
-                visitor, node.type, visibleTypeParameterNames);
-        names.add(name);
-        types.add(type);
-      }
-    }
-
-    List<ResolutionDartType> requiredTypes = <ResolutionDartType>[];
-    NodeList optionalFormals = null;
-    for (Link<Node> link = formals.nodes; !link.isEmpty; link = link.tail) {
-      if (link.tail.isEmpty && link.head is NodeList) {
-        optionalFormals = link.head;
-        break;
-      }
-      requiredTypes.add(resolvePositionalType(link.head));
-    }
-
-
-    List<ResolutionDartType> orderedTypes = const <ResolutionDartType>[];
-    List<String> names = const <String>[];
-    List<ResolutionDartType> namedTypes = const <ResolutionDartType>[];
-
-    if (optionalFormals != null) {
-      // This must be a list of optional arguments.
-      String value = optionalFormals.beginToken.stringValue;
-      if ((!identical(value, '[')) && (!identical(value, '{'))) {
-        reporter.internalError(optionalFormals, "expected optional parameters");
-      }
-      bool optionalParametersAreNamed = (identical(value, '{'));
-
-      if (optionalParametersAreNamed) {
-        names = <String>[];
-        namedTypes = <ResolutionDartType>[];
-        fillNamedTypes(optionalFormals, names, namedTypes);
-      } else {
-        orderedTypes = <ResolutionDartType>[];
-        for (Link<Node> link = optionalFormals.nodes;
-             !link.isEmpty;
-             link = link.tail) {
-          orderedTypes.add(resolvePositionalType(link.head));
-        }
-      }
-    }
-    return new _FormalsTypeResolutionResult(
-        requiredTypes, orderedTypes, names, namedTypes);
-  }
-
-  ResolutionFunctionType _resolveFunctionTypeAnnotation(MappingVisitor visitor,
-      FunctionTypeAnnotation node,
-      List<List<String>> visibleTypeParameterNames,
-      {bool malformedIsError: false, bool deferredIsMalformed: true}) {
-
-    assert(visibleTypeParameterNames != null);
-
-    if (node.typeParameters != null) {
-      List<String> newTypeNames = node.typeParameters.map((TypeVariable node) {
-        return node.name.asIdentifier().source;
-      }).toList();
-      visibleTypeParameterNames =
-          visibleTypeParameterNames.toList()..add(newTypeNames);
-    }
-
-    ResolutionDartType returnType = node.returnType == null
-        ? const ResolutionDynamicType()
-        : _resolveTypeAnnotation(visitor, node.returnType,
-              visibleTypeParameterNames);
-    var formalTypes =
-        _resolveFormalTypes(visitor, node.formals, visibleTypeParameterNames);
-    var result = new ResolutionFunctionType.generalized(
-        returnType,
-        formalTypes.requiredTypes,
-        formalTypes.orderedTypes,
-        formalTypes.names,
-        formalTypes.nameTypes);
-    visitor.registry.useType(node, result);
-    return result;
-  }
-
-  ResolutionDartType resolveNominalTypeAnnotation(MappingVisitor visitor,
-      NominalTypeAnnotation node,
-      List<List<String>> visibleTypeParameterNames,
-      {bool malformedIsError: false, bool deferredIsMalformed: true}) {
     ResolutionRegistry registry = visitor.registry;
 
     Identifier typeName;
@@ -232,8 +74,7 @@ class TypeResolver {
     ResolutionDartType checkNoTypeArguments(ResolutionDartType type) {
       List<ResolutionDartType> arguments = new List<ResolutionDartType>();
       bool hasTypeArgumentMismatch = resolveTypeArguments(
-          visitor, node, const <ResolutionDartType>[], arguments,
-          visibleTypeParameterNames);
+          visitor, node, const <ResolutionDartType>[], arguments);
       if (hasTypeArgumentMismatch) {
         return new MalformedType(
             new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
@@ -265,6 +106,9 @@ class TypeResolver {
       }
     }
 
+    Element element = resolveTypeName(prefixName, typeName, visitor.scope,
+        deferredIsMalformed: deferredIsMalformed);
+
     ResolutionDartType reportFailureAndCreateType(
         MessageKind messageKind, Map messageArguments,
         {ResolutionDartType userProvidedBadType,
@@ -284,33 +128,14 @@ class TypeResolver {
             typeName.source, visitor.enclosingElement);
       }
       List<ResolutionDartType> arguments = <ResolutionDartType>[];
-      resolveTypeArguments(visitor, node, const <ResolutionDartType>[],
-          arguments, visibleTypeParameterNames);
+      resolveTypeArguments(
+          visitor, node, const <ResolutionDartType>[], arguments);
       return new MalformedType(
           erroneousElement, userProvidedBadType, arguments);
     }
 
-    Element element;
-    // Resolve references to type names as dynamic.
-    // TODO(floitsch): this hackishly resolves generic function type arguments
-    // to dynamic.
-    if (prefixName == null &&
-        visibleTypeParameterNames.any((n) => n.contains(typeName.source))) {
-      type = const ResolutionDynamicType();
-    } else {
-      element = resolveTypeName(prefixName, typeName, visitor.scope,
-          deferredIsMalformed: deferredIsMalformed);
-    }
-
     // Try to construct the type from the element.
-    if (type != null) {
-      // Already assigned to through the visibleTypeParameterNames.
-      // Just make sure that it doesn't have type arguments.
-      if (node.typeArguments != null) {
-        reporter.reportWarningMessage(node.typeArguments.nodes.head,
-            MessageKind.ADDITIONAL_TYPE_ARGUMENT);
-      }
-    } else if (element == null) {
+    if (element == null) {
       type = reportFailureAndCreateType(
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
     } else if (element.isAmbiguous) {
@@ -345,9 +170,8 @@ class TypeResolver {
         resolver.ensureClassWillBeResolvedInternal(cls);
         cls.computeType(resolution);
         List<ResolutionDartType> arguments = <ResolutionDartType>[];
-        bool hasTypeArgumentMismatch = resolveTypeArguments(
-            visitor, node, cls.typeVariables, arguments,
-            visibleTypeParameterNames);
+        bool hasTypeArgumentMismatch =
+            resolveTypeArguments(visitor, node, cls.typeVariables, arguments);
         if (hasTypeArgumentMismatch) {
           type = new BadInterfaceType(
               cls.declaration,
@@ -370,8 +194,7 @@ class TypeResolver {
         typdef.computeType(resolution);
         List<ResolutionDartType> arguments = <ResolutionDartType>[];
         bool hasTypeArgumentMismatch = resolveTypeArguments(
-            visitor, node, typdef.typeVariables, arguments,
-            visibleTypeParameterNames);
+            visitor, node, typdef.typeVariables, arguments);
         if (hasTypeArgumentMismatch) {
           type = new BadTypedefType(
               typdef,
@@ -418,7 +241,7 @@ class TypeResolver {
   }
 
   /// Checks the type arguments of [type] against the type variable bounds.
-  void checkTypeVariableBounds(NominalTypeAnnotation node, GenericType type) {
+  void checkTypeVariableBounds(TypeAnnotation node, GenericType type) {
     void checkTypeVariableBound(_, ResolutionDartType typeArgument,
         ResolutionTypeVariableType typeVariable, ResolutionDartType bound) {
       if (!types.isSubtype(typeArgument, bound)) {
@@ -443,10 +266,9 @@ class TypeResolver {
    */
   bool resolveTypeArguments(
       MappingVisitor visitor,
-      NominalTypeAnnotation node,
+      TypeAnnotation node,
       List<ResolutionDartType> typeVariables,
-      List<ResolutionDartType> arguments,
-      List<List<String>> visibleTypeParameterNames) {
+      List<ResolutionDartType> arguments) {
     if (node.typeArguments == null) {
       return false;
     }
@@ -461,8 +283,8 @@ class TypeResolver {
             typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
         typeArgumentCountMismatch = true;
       }
-      ResolutionDartType argType = _resolveTypeAnnotation(
-          visitor, typeArguments.head, visibleTypeParameterNames);
+      ResolutionDartType argType =
+          resolveTypeAnnotation(visitor, typeArguments.head);
       // TODO(karlklose): rewrite to not modify [arguments].
       arguments.add(argType);
     }