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);
+          visitor, node, const <ResolutionDartType>[], arguments,
+          visibleTypeParameterNames);
       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);
+      resolveTypeArguments(visitor, node, const <ResolutionDartType>[],
+          arguments, visibleTypeParameterNames);
       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 (element == null) {
+    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) {
       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);
+        bool hasTypeArgumentMismatch = resolveTypeArguments(
+            visitor, node, cls.typeVariables, arguments,
+            visibleTypeParameterNames);
         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);
+            visitor, node, typdef.typeVariables, arguments,
+            visibleTypeParameterNames);
         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(TypeAnnotation node, GenericType type) {
+  void checkTypeVariableBounds(NominalTypeAnnotation 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,
-      TypeAnnotation node,
+      NominalTypeAnnotation node,
       List<ResolutionDartType> typeVariables,
-      List<ResolutionDartType> arguments) {
+      List<ResolutionDartType> arguments,
+      List<List<String>> visibleTypeParameterNames) {
     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);
+      ResolutionDartType argType = _resolveTypeAnnotation(
+          visitor, typeArguments.head, visibleTypeParameterNames);
       // 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;
   }
 }