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

pkg/compiler/lib/src/resolution/type_resolver.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.types;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart'
     show
         AmbiguousElement,
         ClassElement,
         Element,
         Elements,
         ErroneousElement,
         PrefixElement,
         TypedefElement,
         TypeVariableElement;
 import '../elements/modelx.dart' show ErroneousElementX;
 import '../resolution/resolution.dart';
 import '../tree/tree.dart';
 import '../universe/feature.dart' show Feature;
 import '../util/util.dart' show Link;
 import 'members.dart' show lookupInScope;
 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;
 
   TypeResolver(this.resolution);
 
   ResolverTask get resolver => resolution.resolver;
   DiagnosticReporter get reporter => resolution.reporter;
   Types get types => resolution.types;
 
   /// Tries to resolve the type name as an element.
@@ skipping 19 matching lines @@
       }
     } else {
       element = lookupInScope(reporter, typeName, scope, typeName.source);
     }
     return element;
   }
 
   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;
     ResolutionDartType type;
 
     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,
                 {'type': node}, typeName.source, visitor.enclosingElement),
             type,
             arguments);
       }
       return type;
     }
 
@@ skipping 11 matching lines @@
         registry.useType(node, type);
         return type;
       } else if (identical(typeName.source, 'dynamic')) {
         type = const ResolutionDynamicType();
         checkNoTypeArguments(type);
         registry.useType(node, type);
         return type;
       }
     }
 
+    Element element = resolveTypeName(prefixName, typeName, visitor.scope,
+        deferredIsMalformed: deferredIsMalformed);
+
     ResolutionDartType reportFailureAndCreateType(
         MessageKind messageKind, Map messageArguments,
         {ResolutionDartType userProvidedBadType,
         Element erroneousElement,
         List<DiagnosticMessage> infos: const <DiagnosticMessage>[]}) {
       if (malformedIsError) {
         reporter.reportError(
             reporter.createMessage(node, messageKind, messageArguments), infos);
       } else {
         registry.registerFeature(Feature.THROW_RUNTIME_ERROR);
         reporter.reportWarning(
             reporter.createMessage(node, messageKind, messageArguments), infos);
       }
       if (erroneousElement == null) {
         registry.registerFeature(Feature.THROW_RUNTIME_ERROR);
         erroneousElement = new ErroneousElementX(messageKind, messageArguments,
             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) {
       AmbiguousElement ambiguous = element;
       type = reportFailureAndCreateType(
           ambiguous.messageKind, ambiguous.messageArguments,
           infos: ambiguous.computeInfos(
               registry.mapping.analyzedElement, reporter));
       ;
     } else if (element.isMalformed) {
@@ skipping 14 matching lines @@
       return type;
     } else {
       bool addTypeVariableBoundsCheck = false;
       if (element.isClass) {
         ClassElement cls = element;
         // TODO(johnniwinther): [ensureClassWillBeResolvedInternal] should imply
         // [computeType].
         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,
               new ResolutionInterfaceType.forUserProvidedBadType(
                   cls.declaration, arguments));
         } else {
           if (arguments.isEmpty) {
             type = cls.rawType;
           } else {
             type = new ResolutionInterfaceType(
                 cls.declaration, arguments.toList(growable: false));
             addTypeVariableBoundsCheck =
                 arguments.any((ResolutionDartType type) => !type.isDynamic);
           }
         }
       } else if (element.isTypedef) {
         TypedefElement typdef = element;
         // TODO(johnniwinther): [ensureResolved] should imply [computeType].
         typdef.ensureResolved(resolution);
         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,
               new ResolutionTypedefType.forUserProvidedBadType(
                   typdef, arguments));
         } else {
           if (arguments.isEmpty) {
             type = typdef.rawType;
           } else {
             type = new ResolutionTypedefType(
@@ skipping 26 matching lines @@
       if (addTypeVariableBoundsCheck) {
         visitor.addDeferredAction(visitor.enclosingElement,
             () => checkTypeVariableBounds(node, type));
       }
     }
     registry.useType(node, type);
     return type;
   }
 
   /// 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)) {
         reporter.reportWarningMessage(
             node, MessageKind.INVALID_TYPE_VARIABLE_BOUND, {
           'typeVariable': typeVariable,
           'bound': bound,
           'typeArgument': typeArgument,
           'thisType': type.element.thisType
         });
       }
     }
 
     types.checkTypeVariableBounds(type, checkTypeVariableBound);
   }
 
   /**
    * Resolves the type arguments of [node] and adds these to [arguments].
    *
    * Returns [: true :] if the number of type arguments did not match the
    * number of type variables.
    */
   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;
     }
     int expectedVariables = typeVariables.length;
     int index = 0;
     bool typeArgumentCountMismatch = false;
     for (Link<Node> typeArguments = node.typeArguments.nodes;
         !typeArguments.isEmpty;
         typeArguments = typeArguments.tail, index++) {
       if (index > expectedVariables - 1) {
         reporter.reportWarningMessage(
             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);
     }
     if (index < expectedVariables) {
       reporter.reportWarningMessage(
           node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
       typeArgumentCountMismatch = true;
     }
     return typeArgumentCountMismatch;
   }
 }