Rebased and retested version of CL 1915123008.

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

 // Copyright (c) 2014, 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.signatures;
 
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart'
     show
         ErroneousFieldElementX,
         ErroneousInitializingFormalElementX,
         FormalElementX,
         FunctionSignatureX,
         InitializingFormalElementX,
-        LocalParameterElementX;
+        LocalParameterElementX,
+        TypeVariableElementX;
 import '../tree/tree.dart';
 import '../universe/use.dart' show TypeUse;
 import '../util/util.dart' show Link, LinkBuilder;
 import 'members.dart' show ResolverVisitor;
 import 'registry.dart' show ResolutionRegistry;
 import 'resolution_common.dart' show MappingVisitor;
-import 'scope.dart' show Scope;
+import 'scope.dart' show Scope, TypeVariablesScope;
 
 /**
  * [SignatureResolver] resolves function signatures.
  */
 class SignatureResolver extends MappingVisitor<FormalElementX> {
   final ResolverVisitor resolver;
   final FunctionTypedElement enclosingElement;
   final Scope scope;
   final MessageKind defaultValuesError;
   final bool createRealParameters;
   List<Element> optionalParameters = const <Element>[];
   int optionalParameterCount = 0;
   bool isOptionalParameter = false;
   bool optionalParametersAreNamed = false;
   VariableDefinitions currentDefinitions;
 
   SignatureResolver(Compiler compiler, FunctionTypedElement enclosingElement,
+      Scope scope,
       ResolutionRegistry registry,
       {this.defaultValuesError, this.createRealParameters})
-      : this.enclosingElement = enclosingElement,
-        this.scope = enclosingElement.buildScope(),
-        this.resolver =
-            new ResolverVisitor(compiler, enclosingElement, registry),
+      : this.scope = scope,
+        this.enclosingElement = enclosingElement,
+        this.resolver = new ResolverVisitor(
+            compiler, enclosingElement, registry, scope: scope),
         super(compiler, registry);
 
   bool get defaultValuesAllowed => defaultValuesError == null;
 
   visitNodeList(NodeList node) {
     // This must be a list of optional arguments.
     String value = node.beginToken.stringValue;
     if ((!identical(value, '[')) && (!identical(value, '{'))) {
       reporter.internalError(node, "expected optional parameters");
     }
@@ skipping 44 matching lines @@
         Name.isPrivateName(node.source)) {
       reporter.reportErrorMessage(node, MessageKind.PRIVATE_NAMED_PARAMETER);
     }
   }
 
   void computeParameterType(FormalElementX element,
       [VariableElement fieldElement]) {
     void computeFunctionType(FunctionExpression functionExpression) {
       FunctionSignature functionSignature = SignatureResolver.analyze(
           compiler,
+          scope,
+          functionExpression.typeVariables,
           functionExpression.parameters,
           functionExpression.returnType,
           element,
           registry,
           defaultValuesError: MessageKind.FUNCTION_TYPE_FORMAL_WITH_DEFAULT);
       element.functionSignature = functionSignature;
     }
 
     if (currentDefinitions.type != null) {
       element.typeCache = resolveTypeAnnotation(currentDefinitions.type);
@@ skipping 157 matching lines @@
   /**
    * Resolves formal parameters and return type of a [FunctionExpression]
    * to a [FunctionSignature].
    *
    * If [createRealParameters] is `true`, the parameters will be
    * real parameters implementing the [ParameterElement] interface. Otherwise,
    * the parameters will only implement [FormalElement].
    */
   static FunctionSignature analyze(
       Compiler compiler,
+      Scope scope,
+      NodeList typeVariables,
       NodeList formalParameters,
       Node returnNode,
       FunctionTypedElement element,
       ResolutionRegistry registry,
       {MessageKind defaultValuesError,
       bool createRealParameters: false,
       bool isFunctionExpression: false}) {
     DiagnosticReporter reporter = compiler.reporter;
 
+    List<DartType> createTypeVariables(NodeList typeVariableNodes) {
+      if (typeVariableNodes == null) return const <DartType>[];
+
+      // Create the types and elements corresponding to [typeVariableNodes].
+      Link<Node> nodes = typeVariableNodes.nodes;
+      List<DartType> arguments =
+          new List.generate(nodes.slowLength(), (int index) {
+        TypeVariable node = nodes.head;
+        String variableName = node.name.source;
+        nodes = nodes.tail;
+        TypeVariableElementX variableElement =
+            new TypeVariableElementX(variableName, element, index, node);
+        // TODO(eernst): When type variables are implemented fully we will need
+        // to resolve the actual bounds; currently we just claim [dynamic].
+        variableElement.boundCache = const DynamicType();
+        TypeVariableType variableType = new TypeVariableType(variableElement);
+        variableElement.typeCache = variableType;
+        return variableType;
+      }, growable: false);
+      return arguments;
+    }
+
+    List<DartType> typeVariableTypes = createTypeVariables(typeVariables);
+    scope = new FunctionSignatureBuildingScope(scope, typeVariableTypes);
     SignatureResolver visitor = new SignatureResolver(
-        compiler, element, registry,
+        compiler, element, scope, registry,
         defaultValuesError: defaultValuesError,
         createRealParameters: createRealParameters);
     List<Element> parameters = const <Element>[];
     int requiredParameterCount = 0;
     if (formalParameters == null) {
       if (!element.isGetter) {
         if (element.isMalformed) {
           // If the element is erroneous, an error should already have been
           // reported. In the case of parse errors, it is possible that there
           // are formal parameters, but something else in the method failed to
@@ skipping 93 matching lines @@
           optionalParameterTypesBuilder.toLink().toList(growable: false);
     }
     FunctionType type = new FunctionType(
         element.declaration,
         returnType,
         parameterTypes.toLink().toList(growable: false),
         optionalParameterTypes,
         namedParameters,
         namedParameterTypes);
     return new FunctionSignatureX(
+        typeVariables: typeVariableTypes,
         requiredParameters: parameters,
         optionalParameters: visitor.optionalParameters,
         requiredParameterCount: requiredParameterCount,
         optionalParameterCount: visitor.optionalParameterCount,
         optionalParametersAreNamed: visitor.optionalParametersAreNamed,
         orderedOptionalParameters: orderedOptionalParameters,
         type: type);
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation annotation) {
     DartType type = resolveReturnType(annotation);
     if (type.isVoid) {
       reporter.reportErrorMessage(annotation, MessageKind.VOID_NOT_ALLOWED);
     }
     return type;
   }
 
   DartType resolveReturnType(TypeAnnotation annotation) {
     if (annotation == null) return const DynamicType();
     DartType result = resolver.resolveTypeAnnotation(annotation);
     if (result == null) {
       return const DynamicType();
     }
     return result;
   }
 }
+
+/// Used during `SignatureResolver.analyze` to provide access to the type
+/// variables of the function signature itself when its signature is analyzed.
+class FunctionSignatureBuildingScope extends TypeVariablesScope {
+  @override
+  final List<DartType> typeVariables;
+
+  FunctionSignatureBuildingScope(Scope parent, this.typeVariables)
+      : super(parent);
+
+  String toString() => 'FunctionSignatureBuildingScope($typeVariables)';
+}